adding UncheckedCast

Author: jsiek

interp_Clambda.py

@@ -25,5 +25,7 @@ def interp_exp(self, e, env):
       case AllocateClosure(length, typ, arity):
         array = [None] * length
         return ClosureTuple(array, arity)
+      case UncheckedCast(exp, ty):
+        return self.interp_exp(exp, env)
       case _:
         return super().interp_exp(e, env)

interp_Lany.py

@@ -50,6 +50,8 @@ def interp_exp(self, e, env):
     match e:
       case Inject(value, typ):
         v = self.interp_exp(value, env)
+        if isinstance(value, Tagged):
+          raise Exception('cannot inject a value that is already tagged')
         return Tagged(v, self.type_to_tag(typ))
       case Project(value, typ):
         v = self.interp_exp(value, env)
@@ -58,7 +60,7 @@ def interp_exp(self, e, env):
             return val
           case _:
             raise Exception('interp project to ' + repr(typ) \
-                            + '  unexpected ' + repr(v))
+                            + '  unexpected ' + repr(v) + '\nin\n' + str(e))
       case Call(Name(atl), [tup, index]) \
           if atl == 'any_load' or atl == 'any_load_unsafe':
         tv = self.interp_exp(tup, env)
@@ -93,6 +95,8 @@ def interp_exp(self, e, env):
       case Call(Name('make_any'), [value, tag]):
         v = self.interp_exp(value, env)
         t = self.interp_exp(tag, env)
+        if isinstance(v, Tagged):
+          raise Exception('cannot inject a value that is already tagged')
         return Tagged(v, t)
       case Call(Name('arity'), [fun]):
         f = self.interp_exp(fun, env)

interp_Llambda.py

@@ -39,6 +39,8 @@ def interp_exp(self, e, env):
         return env[id]
       case Lambda(params, body):
         return Function('lambda', params, [Return(body)], env)
+      case UncheckedCast(exp, ty):
+        return self.interp_exp(exp, env)
       case Closure(arity, args):
         return ClosureTuple([self.interp_exp(arg, env) for arg in args], arity)
       case AllocateClosure(length, typ, arity):

type_check_Cif.py

@@ -116,9 +116,10 @@ def type_check(self, p):
               self.type_check_tail(ss[-1], env)
               if env == old_env:
                   break
-          undefs = [x for x,t in env.items() if t == Bottom()]
-          if undefs:
-              raise Exception('error: undefined type for ' + str(undefs)) 
+          # because of explicate_control there can be undefined vars -Jeremy
+          # undefs = [x for x,t in env.items() if t == Bottom()]
+          # if undefs:
+          #     raise Exception('error: undefined type for ' + str(undefs)) 
           p.var_types = env
       case _:
         raise Exception('error in type_check, unexpected ' + repr(p))

type_check_Clambda.py

@@ -1,4 +1,4 @@
-from utils import AllocateClosure, Uninitialized
+from utils import AllocateClosure, Uninitialized, UncheckedCast
 from type_check_Cfun import TypeCheckCfun
 
 class TypeCheckClambda(TypeCheckCfun):
@@ -9,6 +9,9 @@ def type_check_exp(self, e, env):
         return ty
       case AllocateClosure(length, typ, arity):
         return typ
+      case UncheckedCast(exp, ty):
+        self.type_check_exp(exp, env)
+        return ty
       case _:
         return super().type_check_exp(e, env)
 

type_check_Larray.py

@@ -85,7 +85,7 @@ def type_check_exp(self, e, env):
           case Bottom():
             return VoidType()
           case _:
-            raise Exception('type_check_stmts: unexpected ' + repr(tup_t))
+            raise Exception('type_check_exp: unexpected ' + repr(tup_t))
       case BinOp(left, Mult(), right):
         l = self.type_check_exp(left, env)
         self.check_type_equal(l, IntType(), left)
@@ -111,7 +111,11 @@ def type_check_stmts(self, ss, env):
           case TupleType(ts):
             match index:
               case Constant(i):
-                self.check_type_equal(ts[i], value_t, ss[0])
+                if 0 <= i and i < len(ts):
+                  self.check_type_equal(ts[i], value_t, ss[0])
+                else:
+                  raise Exception('subscript ' + str(i) + ' not in range of '
+                                  + str(tup_t) + ' in\n' + str(ss[0]))
               case _:
                 raise Exception('subscript required constant integer index')
           case ListType(ty):

type_check_Lgrad.py

@@ -171,6 +171,45 @@ def type_check_exp(self, e, env):
         e.has_type = ListType(elt_ty)
         return e.has_type
 
+      case Call(Name('array_len'), [tup]):
+        tup_t = self.type_check_exp(tup, env)
+        tup.has_type = tup_t
+        match tup_t:
+          case ListType(ty):
+            return IntType()
+          case Bottom():
+            return Bottom()
+          case AnyType():
+            return IntType()
+          case _:
+            raise Exception('array_len: unexpected ' + repr(tup_t))
+      case Call(Name('array_load'), [lst, index]):
+        lst_ty = self.type_check_exp(lst, env)
+        index_ty = self.type_check_exp(index, env)
+        self.check_consistent(index_ty, IntType(), index)
+        match lst_ty:
+          case ListType(ty):
+            return ty
+          case AnyType():
+            return AnyType()
+          case _:
+            raise Exception('array_load: unexpected ' + repr(lst_ty))
+      case Call(Name('array_store'), [tup, index, value]):
+        tup_t = self.type_check_exp(tup, env)
+        value_t = self.type_check_exp(value, env)
+        index_ty = self.type_check_exp(index, env)
+        self.check_consistent(index_ty, IntType(), index)
+        match tup_t:
+          case ListType(ty):
+            self.check_consistent(ty, value_t, e)
+            return VoidType()
+          case Bottom():
+            return VoidType()
+          case AnyType():
+            return VoidType()
+          case _:
+            raise Exception('type_check_exp: unexpected ' + repr(tup_t))
+      
       # Cases for Llambda
       case Lambda(params, body):
         self.check_exp(e, AnyType(), env)
@@ -185,18 +224,35 @@ def type_check_exp(self, e, env):
           case _:
             raise Exception('type_check_exp: in arity, unexpected ' + \
                             repr(func_t))
+          
+      # primitives introduced by the resolve pass
+      case Call(Name('any_load'), [tup, index]):
+        self.check_exp(tup, AnyType(), env)
+        self.check_exp(index, IntType(), env)
+        return AnyType()
+      case Call(Name('any_store'), [tup, index, value]):
+        self.check_exp(tup, AnyType(), env)
+        self.type_check_exp(value, env)
+        self.check_exp(index, IntType(), env)
+        return VoidType()
+      case Call(Name('any_len'), [tup]):
+        self.check_exp(tup, AnyType(), env)
+        return IntType()
+      
       # Cases for Lfun (last because the below Call pattern is general)
       case FunRef(id, arity):
         return env[id]
       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):
-                self.check_consistent(param_t, arg_t, e)
+            for (arg, param_t) in zip(args, params_t):
+                self.check_exp(arg, param_t, env)
+            # for (arg_t, param_t) in zip(args_t, params_t):
+            #     self.check_consistent(param_t, arg_t, e)
             return return_t
           case AnyType():
+            args_t = [self.type_check_exp(arg, env) for arg in args]
             anys = [AnyType() for _ in args_t]
             fun_ty = FunctionType(anys, AnyType())
             return AnyType()
@@ -209,6 +265,7 @@ def type_check_exp(self, e, env):
   def check_exp(self, e, ty, env):
     match e:
       case Lambda(params, body):
+        trace('check_exp: ' + str(e) + '\nexpected type: ' + str(ty))
         if isinstance(params, ast.arguments):
           new_params = [a.arg for a in params.args]
           e.args = new_params

type_check_Llambda.py

@@ -9,17 +9,36 @@
 
 class TypeCheckLlambda(TypeCheckLfun):
 
+  # Example:
+  # given: Callable[[tuple[bottom,tuple[int]], int], int]
+  # output: tuple[Callable[[tuple[],int], int]]:
+  def closure_type(self, fun_ty):
+    match fun_ty:
+      case FunctionType(params, rt):
+        return TupleType([FunctionType([TupleType([])] + params[1:], rt)])
+      case _:
+        raise Exception('erase_closure_type expected function type, not '
+                        + str(fun_ty))
+  
   def type_check_exp(self, e, env):
     match e:
       case Name(id):
         e.has_type = env[id]
         return env[id]
       case FunRef(id, arity):
-        return env[id]
+        e.has_type = env[id]
+        return e.has_type
+      case UncheckedCast(exp, ty):
+        self.type_check_exp(exp, env)
+        return ty
       case Closure(arity, es):
         ts = [self.type_check_exp(e, env) for e in es]
+        # closure values with different shapes must be given compatible types
+        # e.has_type and e.erased_type is used in expose_allocation
         e.has_type = TupleType(ts)
-        return e.has_type  # this is just wrong: closure values with different shapes must be given compatible types
+        function_type = ts[0]
+        e.erased_type = self.closure_type(function_type)
+        return e.erased_type
       case Lambda(params, body):
         raise Exception('cannot synthesize a type for lambda: ' + str(e))
       case AllocateClosure(length, typ, arity):
@@ -42,11 +61,10 @@ def type_check_exp(self, e, env):
           case FunctionType(params_t, return_t):
             for (arg, param_t) in zip(args, params_t):
                 self.check_exp(arg, param_t, env)
-            # self.check_type_equal(return_t, ty, e)
             return return_t
           case _:
-            raise Exception('type_check_exp: in call, unexpected ' + \
-                            repr(func_t))
+            raise Exception('type_check_exp: unexpected ' + \
+                            repr(func_t) + '\nin call\n' + str(e))
       case Uninitialized(ty):
         return ty
       case _:

utils.py

@@ -747,6 +747,11 @@ def __str__(self):
         return 'alloc_clos(' + str(self.length) + ',' + str(self.ty) \
                + ',' + str(self.arity) + ')'
 
+@dataclass
+class UncheckedCast(expr):
+    exp: expr
+    ty: Type
+    __match_args__ = ("exp","ty")
 
 @dataclass
 class Collect(stmt):
@@ -766,7 +771,7 @@ class Begin(expr):
     def __str__(self):
         indent()
         stmts = ''.join([str(s) for s in self.body])
-        end = indent_stmt() + + 'produce ' + str(self.result)
+        end = indent_stmt() + 'produce ' + str(self.result)
         dedent()
         return '{\n' + stmts + end + '}'
 
@@ -877,7 +882,11 @@ class Closure(expr):
     __match_args__ = ("arity", "args")
 
     def __str__(self):
-        return 'closure{' + repr(self.arity) + '}(' + ', '.join([str(e) for e in self.args]) + ')'
+        if hasattr(self, 'has_type'):
+            typ = ':' + str(self.has_type)
+        else:
+            typ = ''
+        return 'closure{' + repr(self.arity) + '}(' + ', '.join([str(e) for e in self.args]) + ')' + typ
 
 
 @dataclass