fixes

Author: jsiek

interp_Lint.py

@@ -75,4 +75,4 @@ def interp(self, p):
   ast1_1 = BinOp(read, Add(), neg_eight)
   pr = Expr(Call(Name('print'), [ast1_1]))
   p = Module([pr])
-  interp_Lint(p)
+  interp(p)

type_check_Cfun.py

@@ -5,27 +5,27 @@
 
 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 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 type_check_exp(self, e, env):
     match e:
@@ -53,8 +53,8 @@ def type_check_def(self, d, env):
     match d:
       case FunctionDef(name, params, blocks, dl, returns, comment):
         new_env = {x: t for (x,t) in env.items()}
-        for p in params.args:
-            new_env[p.arg] = self.parse_type_annot(p.annotation)
+        for (x,t) in params:
+            new_env[x] = t
         while True:
             old_env = copy.deepcopy(new_env)
             for (l,ss) in blocks.items():
@@ -66,7 +66,7 @@ def type_check_def(self, d, env):
         # trace('type_check_Cfun var_types for ' + name)
         # trace(d.var_types)
       case _:
-        raise Exception('type_check_def: unexpected ' + repr(ss[0]))
+        raise Exception('type_check_def: unexpected ' + repr(d))
 
   def type_check_stmts(self, ss, env):
     if len(ss) == 0:
@@ -84,10 +84,8 @@ def type_check(self, p):
         for d in defs:
             match d:
               case FunctionDef(name, params, bod, dl, returns, comment):
-                params_t = [self. parse_type_annot(p.annotation) \
-                            for p in params.args]
-                env[name] = FunctionType(params_t,
-                                         self.parse_type_annot(returns))
+                params_t = [t for (x,t) in params]
+                env[name] = FunctionType(params_t, returns)
         for d in defs:
             self.type_check_def(d, env)
       case _:

type_check_Cif.py

@@ -64,7 +64,8 @@ def type_check_exp(self, e, env):
         return int
       case Let(Name(x), rhs, body):
         t = self.type_check_exp(rhs, env)
-        new_env = dict(env); new_env[x] = t
+        new_env = dict(env)
+        new_env[x] = t
         return self.type_check_exp(body, new_env)
       case _:
         raise Exception('error in type_check_exp, unexpected ' + repr(e))
@@ -91,7 +92,7 @@ def type_check_stmt(self, s, env):
       case Goto(label):
         pass
       case Return(value):
-        value_t = self.type_check_exp(value, env);
+        value_t = self.type_check_exp(value, env)
       case _:
         raise Exception('error in type_check_stmt, unexpected' + repr(s))
 
@@ -108,7 +109,7 @@ def type_check(self, p):
               for (l, ss) in body.items():
                   self.type_check_stmts(ss, env)
               if env == old_env:
-                  break;
+                  break
           p.var_types = env
       case _:
         raise Exception('error in type_check, unexpected ' + repr(p))

type_check_Ctup.py

@@ -8,7 +8,7 @@ class TypeCheckCtup(TypeCheckCwhile):
   def type_check_exp(self, e, env):
     match e:
         case Allocate(length, typ):
-          return typ;
+          return typ
         case Begin(ss, e):
           self.type_check_stmts(ss, env)
           return self.type_check_exp(e, env)