update type checkers and interpreters

Author: jsiek

interp-Rvar.py

@@ -0,0 +1,21 @@
+from utils import input_int
+
+class InterpRVar:
+
+    def interp_exp(env, e):
+        match e:
+            case Constant(n):
+              return n
+            case Call(Name('input_int'), []):
+              return input_int()
+            case UnaryOp(USub(), e1):
+              return - interp_exp(e1)
+            case BinOp(e1, Add(), e2):
+              return interp_exp(e1) + interp_exp(e2)
+            case _:
+              return False
+
+    def interp_Rint(p):
+        match p:
+            case Module(e):
+              

interpRvar.py

@@ -0,0 +1,40 @@
+from utils import input_int
+
+class InterpRVar:
+
+  def interp_exp(env, e):
+    match e:
+      case Constant(n):
+        return n
+      case Call(Name('input_int'), []):
+        return input_int()
+      case UnaryOp(USub(), e1):
+        return - interp_exp(e1)
+      case BinOp(e1, Add(), e2):
+        return interp_exp(e1) + interp_exp(e2)
+      case _:
+        return False
+
+  def interp_stmt(s):
+    match s:
+      case Call(Name('print'), [e]):
+        print(interp_exp(e)) 
+      case Expr(e):
+        interp_exp(e) 
+      case _:
+        return 
+
+  def interp_Rint(p):
+    match p:
+      case Module(body):
+        for s in body:
+            interp_stmt(s)
+
+if __name__ == "__main__":
+  eight = Constant(8)
+  neg_eight = UnaryOp(USub(), eight)
+  read = Call(Name('input_int'), [])
+  ast1_1 = BinOp(read, Add(), neg_eight)
+  pr = Call(Name('print'), [ast1_1])
+  p = Module([pr])
+  interp_Rint(p)

interp_Cfun.py

@@ -25,6 +25,8 @@ def interp_exp(self, e, env):
     match e:
       case Call(Name('input_int'), []):
         return super().interp_exp(e, env)      
+      case Call(Name('len'), [tup]):
+        return super().interp_exp(e, env)      
       case Call(func, args):
         f = self.interp_exp(func, env)
         vs = [self.interp_exp(arg, env) for arg in args]

interp_Lfun.py

@@ -26,7 +26,7 @@ def apply_fun(self, fun, args, e):
 
   def interp_exp(self, e, env):
     match e:
-      case Call(Name('input_int'), []):
+      case Call(Name(f), args) if (f == 'input_int') or (f == 'len') or (f == 'print'):
         return super().interp_exp(e, env)      
       case Call(func, args):
         f = self.interp_exp(func, env)

interp_Ltup.py

@@ -14,7 +14,8 @@ def interp_cmp(self, cmp):
   def interp_exp(self, e, env):
     match e:
       case Tuple(es, Load()):
-        return tuple([self.interp_exp(e, env) for e in es])
+        # use a list for mutability
+        return [self.interp_exp(e, env) for e in es]
       case Subscript(tup, index, Load()):
         t = self.interp_exp(tup, env)
         n = self.interp_exp(index, env)

type_check_Cfun.py

@@ -1,45 +1,41 @@
 from ast import *
 from utils import *
-from type_check_Ctup import check_type_equal, TypeCheckCtup
+from type_check_Ctup import TypeCheckCtup
 import copy
 
 class TypeCheckCfun(TypeCheckCtup):
-    
-  # def parse_type_annot(self, annot):
-  #     match annot:
-  #       case Name(id):
-  #         if id == 'int':
-  #           return int
-  #         elif id == 'bool':
-  #           return bool
-  #         else:
-  #           raise Exception('parse_type_annot: unexpected ' + repr(annot))
-  #       case TupleType(ts):
-  #         return TupleType([self.parse_type_annot(t) for t in ts])
-  #       case FunctionType(ps, rt):
-  #         return FunctionType([self.parse_type_annot(t) for t in ps],
-  #                             self.parse_type_annot(rt))
-  #       case Subscript(Name('Callable'), Tuple([ps, rt])):
-  #         return FunctionType([self.parse_type_annot(t) for t in ps.elts],
-  #                             self.parse_type_annot(rt))
-  #       case Subscript(Name('tuple'), Tuple(ts)):
-  #         return TupleType([self.parse_type_annot(t) for t in ts])
-  #       case _:
-  #           raise Exception('parse_type_annot: unexpected ' + repr(annot))
-    
+
+  def check_type_equal(self, t1, t2, e):
+    if t1 == Bottom() or t2 == Bottom():
+      return
+    match t1:
+      case FunctionType(ps1, rt1):
+        match t2:
+          case FunctionType(ps2, rt2):
+            for (p1,p2) in zip(ps1, ps2):
+              self.check_type_equal(p1, p2, e)
+              self.check_type_equal(rt1, rt2, e)
+          case _:
+            raise Exception('error: ' + repr(t1) + ' != ' + repr(t2) \
+                            + ' in ' + repr(e))
+      case _:
+        super().check_type_equal(t1, t2, e)
+  
   def type_check_exp(self, e, env):
     match e:
       case FunRef(id):
         return env[id]
       case Call(Name('input_int'), []):
         return super().type_check_exp(e, env)      
+      case Call(Name('len'), [tup]):
+        return super().type_check_exp(e, env)      
       case Call(func, args):
         func_t = self.type_check_exp(func, env)
         args_t = [self.type_check_exp(arg, env) for arg in args]
         match func_t:
           case FunctionType(params_t, return_t):
             for (arg_t, param_t) in zip(args_t, params_t):
-                check_type_equal(param_t, arg_t, e)
+                self.check_type_equal(param_t, arg_t, e)
             return return_t
           case Bottom():
             return Bottom()

type_check_Cif.py

@@ -2,14 +2,14 @@
 from utils import CProgram, Goto, trace, Bottom, Let
 import copy
 
-def check_type_equal(t1, t2, e):
+class TypeCheckCif:
+
+  def check_type_equal(self, t1, t2, e):
     if t1 == Bottom() or t2 == Bottom():
-        pass
+      pass
     elif t1 != t2:
-        raise Exception('error: ' + repr(t1) + ' != ' + repr(t2) \
-                        + ' in ' + repr(e))
-
-class TypeCheckCif:
+      raise Exception('error: ' + repr(t1) + ' != ' + repr(t2) \
+                      + ' in ' + repr(e))
 
   def type_check_atm(self, e, env):
     match e:
@@ -30,35 +30,35 @@ def type_check_exp(self, e, env):
         return self.type_check_atm(e, env)
       case IfExp(test, body, orelse):
         test_t = self.type_check_exp(test, env)
-        check_type_equal(bool, test_t, test)
+        self.check_type_equal(bool, test_t, test)
         body_t = self.type_check_exp(body, env)
         orelse_t = self.type_check_exp(orelse, env)
-        check_type_equal(body_t, orelse_t, e)
+        self.check_type_equal(body_t, orelse_t, e)
         return body_t
       case BinOp(left, op, right) if isinstance(op, Add) or isinstance(op, Sub):
         l = self.type_check_atm(left, env)
-        check_type_equal(l, int, e)
+        self.check_type_equal(l, int, e)
         r = self.type_check_atm(right, env)
-        check_type_equal(r, int, e)
+        self.check_type_equal(r, int, e)
         return int
       case UnaryOp(USub(), v):
         t = self.type_check_atm(v, env)
-        check_type_equal(t, int, e)
+        self.check_type_equal(t, int, e)
         return int
       case UnaryOp(Not(), v):
         t = self.type_check_exp(v, env)
-        check_type_equal(t, bool, e)
+        self.check_type_equal(t, bool, e)
         return bool 
       case Compare(left, [cmp], [right]) if isinstance(cmp, Eq) or isinstance(cmp, NotEq):
         l = self.type_check_atm(left, env)
         r = self.type_check_atm(right, env)
-        check_type_equal(l, r, e)
+        self.check_type_equal(l, r, e)
         return bool
       case Compare(left, [cmp], [right]):
         l = self.type_check_atm(left, env)
-        check_type_equal(l, int, left)
+        self.check_type_equal(l, int, left)
         r = self.type_check_atm(right, env)
-        check_type_equal(r, int, right)
+        self.check_type_equal(r, int, right)
         return bool
       case Call(Name('input_int'), []):
         return int
@@ -79,18 +79,18 @@ def type_check_stmt(self, s, env):
       case Assign([lhs], value):
         t = self.type_check_exp(value, env)
         if lhs.id in env:
-          check_type_equal(env.get(lhs.id, Bottom()), t, s)
+          self.check_type_equal(env.get(lhs.id, Bottom()), t, s)
         else:
           env[lhs.id] = t
       case Expr(Call(Name('print'), [arg])):
         t = self.type_check_exp(arg, env)
-        check_type_equal(t, int, s)
+        self.check_type_equal(t, int, s)
       case Expr(value):
         self.type_check_exp(value, env)
       case If(Compare(left, [cmp], [right]), body, orelse):
         left_t = self.type_check_atm(left, env)
         right_t = self.type_check_atm(right, env)
-        check_type_equal(left_t, right_t, s) # not quite strict enough
+        self.check_type_equal(left_t, right_t, s) # not quite strict enough
         self.type_check_stmts(body, env)
         self.type_check_stmts(orelse, env)
       case Goto(label):

type_check_Ctup.py

@@ -1,10 +1,24 @@
 from ast import *
-from type_check_Cif import check_type_equal, Bottom
 from type_check_Cwhile import TypeCheckCwhile
-from utils import Allocate, Begin, GlobalValue, Collect, TupleType
+from utils import Allocate, Begin, GlobalValue, Collect, TupleType, Bottom
 
 class TypeCheckCtup(TypeCheckCwhile):
-    
+
+  def check_type_equal(self, t1, t2, e):
+    match t1:
+      case TupleType(ts1):
+        match t2:
+          case TupleType(ts2):
+            for (ty1, ty2) in zip(ts1,ts2):
+              self.check_type_equal(ty1, ty2, e)
+          case Bottom():
+            pass
+          case _:
+            raise Exception('error: ' + repr(t1) + ' != ' + repr(t2) \
+                      + ' in ' + repr(e))
+      case _:
+        super().check_type_equal(t1, t2, e)
+  
   def type_check_exp(self, e, env):
     match e:
         case Allocate(length, typ):
@@ -36,16 +50,17 @@ def type_check_stmt(self, s, env):
     match s:      
       case Collect(size):
         pass
-      case Assign([Subscript(tup, Constant(index))], value):
+      case Assign([Subscript(tup, Constant(index), Store())], value):
         tup_t = self.type_check_atm(tup, env)
         value_t = self.type_check_atm(value, env)
         match tup_t:
           case TupleType(ts):
-            check_type_equal(ts[index], value_t, s)
+            self.check_type_equal(ts[index], value_t, s)
           case Bottom():
               pass
           case _:
-            raise Exception('error, expected a tuple, not ' + repr(tup_t))
+            raise Exception('type_check_stmt: expected a tuple, not ' \
+                            + repr(tup_t))
       case _:
         return super().type_check_stmt(s, env)
 

type_check_Lfun.py

@@ -1,12 +1,27 @@
 import ast
 from ast import *
-from type_check_Lvar import check_type_equal
 from type_check_Ltup import TypeCheckLtup
 from utils import *
 import typing
 
 class TypeCheckLfun(TypeCheckLtup):
 
+  def check_type_equal(self, t1, t2, e):
+    if t1 == Bottom() or t2 == Bottom():
+      return
+    match t1:
+      case FunctionType(ps1, rt1):
+        match t2:
+          case FunctionType(ps2, rt2):
+            for (p1,p2) in zip(ps1, ps2):
+              self.check_type_equal(p1, p2, e)
+              self.check_type_equal(rt1, rt2, e)
+          case _:
+            raise Exception('error: ' + repr(t1) + ' != ' + repr(t2) \
+                            + ' in ' + repr(e))
+      case _:
+        super().check_type_equal(t1, t2, e)
+  
   def parse_type_annot(self, annot):
       match annot:
         case Name(id):
@@ -26,8 +41,10 @@ def parse_type_annot(self, annot):
                               self.parse_type_annot(rt))
         case Subscript(Name('tuple'), Tuple(ts)):
           return TupleType([self.parse_type_annot(t) for t in ts])
-        case t if t == int or t == bool:
+        case t if t == int or t == bool or t == type(None):
           return annot
+        case Constant(None):
+          return type(None)
         case _:
             raise Exception('parse_type_annot: unexpected ' + repr(annot))
 
@@ -37,13 +54,15 @@ def type_check_exp(self, e, env):
         return env[id]
       case Call(Name('input_int'), []):
         return super().type_check_exp(e, env)      
+      case Call(Name('len'), [tup]):
+        return super().type_check_exp(e, env)      
       case Call(func, args):
         func_t = self.type_check_exp(func, env)
         args_t = [self.type_check_exp(arg, env) for arg in args]
         match func_t:
           case FunctionType(params_t, return_t):
             for (arg_t, param_t) in zip(args_t, params_t):
-                check_type_equal(param_t, arg_t, e)
+                self.check_type_equal(param_t, arg_t, e)
             return return_t
           case _:
             raise Exception('type_check_exp: in call, unexpected ' + \
@@ -68,7 +87,7 @@ def type_check_stmts(self, ss, env):
         for (x,t) in new_params:
             new_env[x] = t
         rt = self.type_check_stmts(body, new_env)
-        check_type_equal(new_returns, rt, ss[0])
+        self.check_type_equal(new_returns, rt, ss[0])
         return self.type_check_stmts(ss[1:], env)
       case Return(value):
         return self.type_check_exp(value, env)