asegavac/boring-lang
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

added return statement

Browse Source
This commit is contained in:
Andrew Segavac
2021-05-30 09:57:41 -06:00
parent 806835f2b9
commit b82566f710
4 changed files with 135 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
boring/main.py
View File

@@ -1,7 +1,7 @@
import sys
from typing import List
from boring.parse import boring_parser, TreeToBoring, pretty_print
from boring.type_checking import TypeChecker
from boring.type_checking import TypeChecker, Context
from boring import typedefs
if __name__ == "__main__":
@@ -11,7 +11,7 @@ if __name__ == "__main__":
result = TreeToBoring().transform(tree)
# pretty_print(result)
type_checker = TypeChecker()
while type_checker.with_module({}, typedefs.builtins, result):
while type_checker.with_module(Context({}, typedefs.builtins, None), result):
print("loop")
# type_checker.with_module({}, result)
pretty_print(result)

16
boring/parse.py
View File

@@ -26,6 +26,7 @@ def pretty_print(clas, indent=0):
UNIT_TYPE = "()"
NEVER_TYPE = "!"
@dataclass
@@ -89,9 +90,15 @@ class VariableUsage:
type: TypeUsage
@dataclass
class ReturnStatement:
source: "Expression"
type: TypeUsage
@dataclass
class Expression:
expression: Union[LiteralInt, LiteralFloat, FunctionCall, "Block", VariableUsage, Operation]
expression: Union[LiteralInt, LiteralFloat, FunctionCall, "Block", ReturnStatement, VariableUsage, Operation]
type: TypeUsage
@@ -150,6 +157,8 @@ boring_grammar = r"""
variable_usage : identifier
return_statement : "return" expression ";"
expression : add_expression
| sub_expression
| factor
@@ -169,6 +178,7 @@ boring_grammar = r"""
| "let" identifier ":" type_usage "=" expression ";"
statement : let_statement
| return_statement
| expression
block : "{" (statement)* "}"
@@ -238,6 +248,10 @@ class TreeToBoring(Transformer):
(variable,) = variable
return VariableUsage(name=variable, type=UnknownTypeUsage())
def return_statement(self, return_expression) -> ReturnStatement:
(return_expression,) = return_expression
return ReturnStatement(source=return_expression, type=DataTypeUsage(name=NEVER_TYPE))
def function_call(self, call) -> FunctionCall:
return FunctionCall(source=call[0], arguments=call[1:], type=UnknownTypeUsage())

166
boring/type_checking.py
View File

@@ -9,15 +9,24 @@ Identified = Union[parse.LetStatement, parse.Function, parse.VariableDeclaration
Environment = Dict[str, Identified]
TypeEnvironment = Dict[str, typedefs.TypeDef]
@dataclass
class Context:
environment: Environment
type_environment: TypeEnvironment
current_function: Optional[parse.Function]
def unify(type_env: TypeEnvironment, first, second) -> bool:
result, changed = type_compare(type_env, first.type, second.type)
def copy(self):
return Context(self.environment.copy(), self.type_environment.copy(), self.current_function)
def unify(ctx: Context, first, second) -> bool:
result, changed = type_compare(ctx, first.type, second.type)
first.type = result
second.type = result
return changed
def type_compare(type_env: TypeEnvironment, first, second) -> (parse.TypeUsage, bool):
def type_compare(ctx: Context, first, second) -> (parse.TypeUsage, bool):
print(first, second)
if isinstance(first, parse.UnknownTypeUsage):
if not isinstance(second, parse.UnknownTypeUsage):
@@ -32,20 +41,20 @@ def type_compare(type_env: TypeEnvironment, first, second) -> (parse.TypeUsage,
second, parse.DataTypeUsage
):
assert second == first
assert first.name in type_env
assert second.name in type_env
assert first.name in ctx.type_environment
assert second.name in ctx.type_environment
return first, False
elif isinstance(first, parse.FunctionTypeUsage) and isinstance(
second, parse.FunctionTypeUsage
):
return_type, changed = type_compare(
type_env, first.return_type, second.return_type
ctx, first.return_type, second.return_type
)
arguments = []
assert len(first.arguments) == len(second.arguments)
for first_arg, second_arg in zip(first.arguments, second.arguments):
argument_type, argument_changed = type_compare(
type_env, first_arg, second_arg
ctx, first_arg, second_arg
)
arguments.append(argument_type)
if argument_changed:
@@ -56,122 +65,157 @@ def type_compare(type_env: TypeEnvironment, first, second) -> (parse.TypeUsage,
class TypeChecker:
def with_module(self, env: Environment, type_env: TypeEnvironment, module: parse.Module) -> bool:
def with_module(self, ctx: Context, module: parse.Module) -> bool:
for function in module.functions:
env[function.name] = function
found = False
ctx.environment[function.name] = function
changed = False
for function in module.functions:
if self.with_function(env, type_env, function):
found = True
return found
if self.with_function(ctx, function):
changed = True
return changed
def with_function(self, env: Environment, type_env: TypeEnvironment, function: parse.Function) -> bool:
function_env = env.copy()
def with_function(self, ctx: Context, function: parse.Function) -> bool:
function_ctx = ctx.copy()
function_ctx.current_function = function
for argument in function.arguments:
function_env[argument.name] = argument
function_ctx.environment[argument.name] = argument
assert isinstance(function.type, parse.FunctionTypeUsage)
type, changed = type_compare(type_env, function.block.type, function.type.return_type)
function.block.type = type
function.type.return_type = type
if self.with_block(function_env, type_env, function.block):
changed = True
changed = self.with_block(function_ctx, function.block)
if not (isinstance(function.block.type, parse.DataTypeUsage) and function.block.type.name == parse.NEVER_TYPE):
type, compare_changed = type_compare(function_ctx, function.block.type, function.type.return_type)
function.block.type = type
function.type.return_type = type
if compare_changed is True:
changed = True
return changed
# Skip variable VariableDeclaration
def with_block(self, env: Environment, type_env: TypeEnvironment, block: parse.Block) -> bool:
block_env = env.copy()
def with_block(self, ctx: Context, block: parse.Block) -> bool:
block_ctx = ctx.copy()
# if parent is void, must be statement
# if parent is type, must be expression
changed = False
for statement in block.statements:
if self.with_statement(block_ctx, statement):
changed = True
final = block.statements[-1]
if isinstance(final, parse.LetStatement):
if isinstance(block.type, parse.UnknownTypeUsage):
found = True
changed = True
block.type = parse.DataTypeUsage(
name=parse.Identifier(name=parse.UNIT_TYPE)
name=parse.UNIT_TYPE
)
else:
assert block.type == parse.DataTypeUsage(
name=parse.Identifier(name=parse.UNIT_TYPE)
name=parse.UNIT_TYPE
)
elif isinstance(final, parse.ReturnStatement):
if isinstance(block.type, parse.UnknownTypeUsage):
changed = True
block.type = parse.DataTypeUsage(
name=parse.NEVER_TYPE
)
else:
assert block.type == parse.DataTypeUsage(
name=parse.NEVER_TYPE
)
elif isinstance(final, parse.Expression):
if unify(type_env, final, block):
changed = True
for statement in block.statements:
if self.with_statement(block_env, type_env, statement):
if unify(block_ctx, final, block):
changed = True
return changed
def with_statement(self, env: Environment, type_env: TypeEnvironment, statement: parse.Statement) -> bool:
def with_statement(self, ctx: Context, statement: parse.Statement) -> bool:
if isinstance(statement, parse.ReturnStatement):
return self.with_return_statement(ctx, statement)
if isinstance(statement, parse.LetStatement):
return self.with_let_statement(env, type_env, statement)
return self.with_let_statement(ctx, statement)
elif isinstance(statement, parse.Expression): # expression
return self.with_expression(env, type_env, statement)
return self.with_expression(ctx, statement)
else:
assert False
def with_let_statement(
self, env: Environment, type_env: TypeEnvironment, let_statement: parse.LetStatement
self, ctx: Context, let_statement: parse.LetStatement
) -> bool:
found = False
env[let_statement.variable_name] = let_statement
changed = unify(type_env, let_statement, let_statement.expression)
if self.with_expression(env, type_env, let_statement.expression):
changed = False
ctx.environment[let_statement.variable_name] = let_statement
if self.with_expression(ctx, let_statement.expression):
changed = True
changed = unify(ctx, let_statement, let_statement.expression)
return changed
def with_expression(self, env: Environment, type_env: TypeEnvironment, expression: parse.Expression) -> bool:
def with_return_statement(
self, ctx: Context, return_statement: parse.ReturnStatement
) -> bool:
changed = self.with_expression(ctx, return_statement.source)
# Doesn't match on an unreachable return
if not (isinstance(return_statement.source.type, parse.DataTypeUsage) and return_statement.source.type.name == parse.NEVER_TYPE):
type, compare_changed = type_compare(ctx, return_statement.source.type, ctx.current_function.type.return_type)
return_statement.source.type = type
ctx.current_function.type.return_type = type
if compare_changed is True:
changed = True
return changed
def with_expression(self, ctx: Context, expression: parse.Expression) -> bool:
subexpression = expression.expression
changed = unify(type_env, subexpression, expression)
changed = False
if isinstance(subexpression, parse.LiteralInt):
if self.with_literal_int(env, type_env, subexpression):
changed = self.with_literal_int(ctx, subexpression)
if unify(ctx, subexpression, expression):
changed = True
return changed
if isinstance(subexpression, parse.LiteralFloat):
if self.with_literal_float(env, type_env, subexpression):
changed = self.with_literal_float(ctx, subexpression)
if unify(ctx, subexpression, expression):
changed = True
return changed
if isinstance(subexpression, parse.FunctionCall):
if self.with_function_call(env, type_env, subexpression):
changed = self.with_function_call(ctx, subexpression)
if unify(ctx, subexpression, expression):
changed = True
return changed
if isinstance(subexpression, parse.Block):
if self.with_block(env, type_env, subexpression):
changed = self.with_block(ctx, subexpression)
if unify(ctx, subexpression, expression):
changed = True
return changed
if isinstance(subexpression, parse.VariableUsage):
if self.with_variable_usage(env, type_env, subexpression):
changed = self.with_variable_usage(ctx, subexpression)
if unify(ctx, subexpression, expression):
changed = True
return changed
if isinstance(subexpression, parse.Operation):
if self.with_operation(env, type_env, subexpression):
changed = self.with_operation(ctx, subexpression)
if unify(ctx, subexpression, expression):
changed = True
return changed
assert False
def with_variable_usage(
self, env: Environment, type_env: TypeEnvironment, variable_usage: parse.VariableUsage
self, ctx: Context, variable_usage: parse.VariableUsage
) -> bool:
return unify(type_env, variable_usage, env[variable_usage.name])
return unify(ctx, variable_usage, ctx.environment[variable_usage.name])
def with_operation(self, env: Environment, type_env: TypeEnvironment, operation: parse.Operation) -> bool:
def with_operation(self, ctx: Context, operation: parse.Operation) -> bool:
changed = False
if unify(type_env, operation, operation.left):
if self.with_expression(ctx, operation.left):
changed = True
if unify(type_env, operation, operation.right):
if self.with_expression(ctx, operation.right):
changed = True
if self.with_expression(env, type_env, operation.left):
if unify(ctx, operation, operation.left):
changed = True
if self.with_expression(env, type_env, operation.right):
if unify(ctx, operation, operation.right):
changed = True
return changed
def with_function_call(
self, env: Environment, type_env: TypeEnvironment, function_call: parse.FunctionCall
self, ctx: Context, function_call: parse.FunctionCall
) -> bool:
changed = False
if isinstance(function_call.source.type, parse.UnknownTypeUsage):
@@ -180,14 +224,14 @@ class TypeChecker:
return_type=parse.UnknownTypeUsage(),
)
changed = True
if self.with_expression(env, type_env, function_call.source):
if self.with_expression(ctx, function_call.source):
changed = True
for argument in function_call.arguments:
if self.with_expression(env, type_env, argument):
if self.with_expression(ctx, argument):
changed = True
return_type, return_changed = type_compare(
type_env, function_call.type, function_call.source.type.return_type
ctx, function_call.type, function_call.source.type.return_type
)
function_call.type = return_type
function_call.source.type.return_type = return_type
@@ -198,7 +242,7 @@ class TypeChecker:
function_call.arguments, function_call.source.type.arguments
):
argument_out_type, argument_changed = type_compare(
type_env, argument.type, function_call.source.type.return_type
ctx, argument.type, function_call.source.type.return_type
)
argument.type = argument_out_type
function_call.source.type.return_type = argument_out_type
@@ -206,13 +250,13 @@ class TypeChecker:
changed = True
return changed
def with_literal_float(self, env: Environment, type_env: TypeEnvironment, literal_float: parse.LiteralFloat) -> bool:
def with_literal_float(self, ctx: Context, literal_float: parse.LiteralFloat) -> bool:
floats = ["F32", "F64", "F128"]
if not isinstance(literal_float.type, parse.UnknownTypeUsage):
assert literal_float.type.name in floats, f"{literal_float.type}"
return False
def with_literal_int(self, env: Environment, type_env: TypeEnvironment, literal_int: parse.LiteralInt) -> bool:
def with_literal_int(self, ctx: Context, literal_int: parse.LiteralInt) -> bool:
ints = ["I8", "I16", "I32", "I64", "I128", "U8", "U16", "U32", "U64", "U128"]
if not isinstance(literal_int.type, parse.UnknownTypeUsage):
assert literal_int.type.name in ints, f"{literal_int.type}"