type checking and function symbols

Author: ssloy

analyzer.py

@@ -5,6 +5,7 @@ def build_symtable(ast):
     if not isinstance(ast, Function) or ast.name != 'main' or ast.deco['type'] != Type.VOID or len(ast.args)>0:
         raise Exception('Cannot find a valid entry point')
     symtable = SymbolTable()
+    symtable.add_fun(ast.name, [], ast.deco)
     process_scope(ast, symtable)
 
 def process_scope(fun, symtable):
@@ -14,54 +15,76 @@ def process_scope(fun, symtable):
         symtable.add_var(*v)
     for v in fun.var:  # process local variables
         symtable.add_var(*v)
+    for f in fun.fun:  # process nested functions: first add function symbols to the table
+        symtable.add_fun(f.name, [d['type'] for v,d in f.args], f.deco)
     for f in fun.fun:  # then process nested function bodies
         process_scope(f, symtable)
     for s in fun.body: # process the list of statements
         process_stat(s, symtable)
     symtable.pop_scope()
 
 def process_stat(n, symtable): # process "statement" syntax tree nodes
-    if isinstance(n, Print):
+    if isinstance(n, Print): # no type checking is necessary
         process_expr(n.expr, symtable)
     elif isinstance(n, Return):
         if n.expr is None: return
         process_expr(n.expr, symtable)
+        if symtable.ret_stack[-1]['type'] != n.expr.deco['type']:
+            raise Exception('Incompatible types in return statement, line %s', n.deco['lineno'])
     elif isinstance(n, Assign):
         process_expr(n.expr, symtable)
         deco = symtable.find_var(n.name)
+        n.deco['type'] = deco['type']
+        if n.deco['type'] != n.expr.deco['type']:
+            raise Exception('Incompatible types in assignment statement, line %s', n.deco['lineno'])
         update_nonlocals(n.name, symtable) # used in "readable" python transpilation only
     elif isinstance(n, FunCall): # no type checking is necessary
         process_expr(n, symtable)
     elif isinstance(n, While):
         process_expr(n.expr, symtable)
+        if n.expr.deco['type'] != Type.BOOL:
+            raise Exception('Non-boolean expression in while statement, line %s', n.deco['lineno'])
         for s in n.body:
             process_stat(s, symtable)
     elif isinstance(n, IfThenElse):
         process_expr(n.expr, symtable)
+        if n.expr.deco['type'] != Type.BOOL:
+            raise Exception('Non-boolean expression in if statement, line %s', n.deco['lineno'])
         for s in n.ibody + n.ebody:
             process_stat(s, symtable)
     else:
         raise Exception('Unknown statement type')
 
 def process_expr(n, symtable): # process "expression" syntax tree nodes
     if isinstance(n, ArithOp):
+        n.deco['type'] = Type.INT
         process_expr(n.left,  symtable)
         process_expr(n.right, symtable)
+        if n.left.deco['type'] != Type.INT or n.right.deco['type'] != Type.INT:
+            raise Exception('Arithmetic operation over non-integer type in line %s', n.deco['lineno'])
     elif isinstance(n, LogicOp):
+        n.deco['type'] = Type.BOOL
         process_expr(n.left,  symtable)
         process_expr(n.right, symtable)
-    elif isinstance(n, Integer):
+        if (n.left.deco['type'] != n.right.deco['type']) or \
+           (n.op in ['<=', '<', '>=', '>'] and n.left.deco['type'] != Type.INT) or \
+           (n.op in ['&&', '||'] and n.left.deco['type'] != Type.BOOL):
+            raise Exception('Boolean operation over incompatible types in line %s', n.deco['lineno'])
+    elif isinstance(n, Integer): # no type checking is necessary
         n.deco['type'] = Type.INT
-    elif isinstance(n, Boolean):
+    elif isinstance(n, Boolean): # no type checking is necessary
         n.deco['type'] = Type.BOOL
-    elif isinstance(n, Var):
+    elif isinstance(n, Var):     # no type checking is necessary
         deco = symtable.find_var(n.name)
+        n.deco['type']   = deco['type']
         update_nonlocals(n.name, symtable) # used in "readable" python transpilation only
     elif isinstance(n, FunCall):
         for s in n.args:
             process_expr(s, symtable)
-    elif isinstance(n, String):
-        pass
+        deco = symtable.find_fun(n.name, [a.deco['type'] for a in n.args])
+        n.deco['type']    = deco['type']
+    elif isinstance(n, String): # no type checking is necessary
+        n.deco['type']  = Type.STRING
     else:
         raise Exception('Unknown expression type', n)
 

symtable.py

@@ -1,7 +1,13 @@
 class SymbolTable():
     def __init__(self):
         self.variables = [{}]     # stack of variable symbol tables
+        self.functions = [{}]     # stack of function symbol tables
         self.ret_stack = [ None ] # stack of enclosing function symbols, useful for return statements
+    def add_fun(self, name, argtypes, deco):  # a function can be identified by its name and a list of argument types, e.g.
+        signature = (name, *argtypes)         # fun foo(x:bool, y:int) : int {...} has ('foo',Type.BOOL,Type.INT) signature
+        if signature in self.functions[-1]:
+            raise Exception('Double declaration of the function %s %s' % (signature[0], signature[1:]))
+        self.functions[-1][signature] = deco
 
     def add_var(self, name, deco):
         if name in self.variables[-1]:
@@ -10,14 +16,23 @@ def add_var(self, name, deco):
 
     def push_scope(self, deco):
         self.variables.append({})
+        self.functions.append({})
         self.ret_stack.append(deco)
 
     def pop_scope(self):
         self.variables.pop()
+        self.functions.pop()
         self.ret_stack.pop()
 
     def find_var(self, name):
         for i in reversed(range(len(self.variables))):
             if name in self.variables[i]:
                 return self.variables[i][name]
         raise Exception('No declaration for the variable %s' % name)
+
+    def find_fun(self, name, argtypes):
+        signature = (name, *argtypes)
+        for i in reversed(range(len(self.functions))):
+            if signature in self.functions[i]:
+                return self.functions[i][signature]
+        raise Exception('No declaration for the function %s' % signature[0], signature[1:])