early draft of closures

Author: DuncanUszkay1

src/builtins.ts

@@ -559,8 +559,6 @@ export namespace BuiltinNames {
   export const rtti_base = "~lib/rt/__rtti_base";
   export const visit_globals = "~lib/rt/__visit_globals";
   export const visit_members = "~lib/rt/__visit_members";
-
-  // std/closure.ts
   export const global_closure = "~lib/closure/__global_closure";
 
   // std/number.ts

src/compiler.ts

@@ -412,13 +412,13 @@ export class Compiler extends DiagnosticEmitter {
     if (options.isWasm64) {
       module.addGlobal(BuiltinNames.heap_base, NativeType.I64, true, module.i64(0));
       module.addGlobal(BuiltinNames.rtti_base, NativeType.I64, true, module.i64(0));
+      module.addGlobal(BuiltinNames.global_closure, NativeType.I64, true, module.i64(-1));
     } else {
       module.addGlobal(BuiltinNames.heap_base, NativeType.I32, true, module.i32(0));
       module.addGlobal(BuiltinNames.rtti_base, NativeType.I32, true, module.i32(0));
+      module.addGlobal(BuiltinNames.global_closure, NativeType.I32, true, module.i32(-1));
     }
 
-    module.addGlobal(BuiltinNames.global_closure, NativeType.I32, true, module.i32(-1));
-
     // compile entry file(s) while traversing reachable elements
     var files = program.filesByName;
     // TODO: for (let file of files.values()) {
@@ -1826,6 +1826,10 @@ export class Compiler extends DiagnosticEmitter {
     var functionTable = this.functionTable;
     var tableBase = this.options.tableBase;
     if (!tableBase) tableBase = 1; // leave first elem blank
+    // Skip every 16th entry, which is resevered for closures
+    if (tableBase + functionTable.length % 16 == 0) {
+      functionTable.push("")
+    }
     index = tableBase + functionTable.length;
     if (!instance.is(CommonFlags.TRAMPOLINE) && instance.signature.requiredParameters < instance.signature.parameterTypes.length) {
       // insert the trampoline if the function has optional parameters
@@ -3411,7 +3415,7 @@ export class Compiler extends DiagnosticEmitter {
     // pretend to retain the expression immediately so the autorelease, if any, is skipped
     var expr = this.compileExpression(expression, returnType, constraints | Constraints.WILL_RETAIN);
     var flow = this.currentFlow;
-    if (returnType.isManaged || returnType.signatureReference) {
+    if (returnType.isManaged) {
       // check if that worked, and if it didn't, keep the reference alive
       if (!this.skippedAutoreleases.has(expr)) {
         let index = this.tryUndoAutorelease(expr, flow);
@@ -3464,8 +3468,17 @@ export class Compiler extends DiagnosticEmitter {
         }
         fromType = fromType.nonNullableType;
       }
+      // When we convert from the closure type into a function pointer, we first
+      // update the local copy of the scope with the newest values
       if(fromType.is(TypeFlags.CLOSURE)) {
-        return module.block(null, [this.injectClosedLocals(expr, fromType), expr], NativeType.I32)
+        //Retain the Closure Class memory so it isn't freed when we change it into a function ptr
+        if (!this.skippedAutoreleases.has(expr)) {
+          let index = this.tryUndoAutorelease(expr, this.currentFlow);
+          if (index == -1) expr = this.makeRetain(expr);
+          this.skippedAutoreleases.add(expr);
+        }
+        // TODO: check first to ensure that signatures are compatible
+        return module.block(null, [this.injectClosedLocals(expr, fromType), expr], toType.toNativeType())
       }
       if (fromType.isAssignableTo(toType)) { // downcast or same
         assert(fromType.kind == toType.kind);
@@ -5803,15 +5816,12 @@ export class Compiler extends DiagnosticEmitter {
         // fall-through
       }
       case ElementKind.LOCAL:
+      case ElementKind.CLOSEDLOCAL:
       case ElementKind.FIELD: {
         targetType = (<VariableLikeElement>target).type;
         if (target.hasDecorator(DecoratorFlags.UNSAFE)) this.checkUnsafe(expression);
         break;
       }
-      case ElementKind.CLOSEDLOCAL: {
-        targetType = Type.i32
-        break;
-      }
       case ElementKind.PROPERTY_PROTOTYPE: { // static property
         let propertyPrototype = <PropertyPrototype>target;
         let setterPrototype = propertyPrototype.setterPrototype;
@@ -5937,21 +5947,12 @@ export class Compiler extends DiagnosticEmitter {
         return this.makeLocalAssignment(local, valueExpr, valueType, tee);
       }
       case ElementKind.CLOSEDLOCAL: {
+        // TODO: ability to update closed over locals
         this.error(
           DiagnosticCode.Not_implemented,
           valueExpression.range
         );
         return module.unreachable();
-        //return module.block(null, [
-          //module.store(
-            //1,
-            //this.module.global_get(BuiltinNames.global_closure, this.options.nativeSizeType),
-            //valueExpr,
-            //NativeType.I32,
-            //4
-          //),
-          //valueExpr
-        //], NativeType.I32)
       }
       case ElementKind.GLOBAL: {
         let global = <Global>target;
@@ -6332,18 +6333,19 @@ export class Compiler extends DiagnosticEmitter {
   ): ExpressionRef {
     var module = this.module;
     var locals = type.locals!;
-    var exprs = new Array<ExpressionRef>();
-    for (let _values = Map_values(locals), i = 0, k = _values.length; i < k; ++i) {
+    let _values = Map_values(locals);
+    var exprs = new Array<ExpressionRef>(_values.length);
+    for (let i = 0, k = _values.length; i < k; ++i) {
       let local = unchecked(_values[i]);
-      exprs.push(module.store(
+      let closureClass= type.classReference!
+      exprs[i] = module.store(
           local.type.byteSize,
           expr,
-          this.module.local_get(local.index, NativeType.I32),
-          NativeType.I32,
-          (i + 1) * 4
-      ))
+          this.module.local_get(local.index, local.type.toNativeType()),
+          local.type.toNativeType(),
+          closureClass.offsetof(local.name)
+      )
     }
-    //exprs.push(module.unreachable())
     return module.block(null, exprs)
   }
 
@@ -6424,7 +6426,6 @@ export class Compiler extends DiagnosticEmitter {
 
     var signature: Signature | null;
     var indexArg: ExpressionRef;
-    var closedLocal: Local | null = null;
     switch (target.kind) {
       // direct call: concrete function
       case ElementKind.FUNCTION_PROTOTYPE: {
@@ -6451,36 +6452,34 @@ export class Compiler extends DiagnosticEmitter {
       // indirect call: index argument with signature (non-generic, can't be inlined)
       case ElementKind.LOCAL: {
         let local = <Local>target;
+        signature = local.type.signatureReference;
         if(local.type.is(TypeFlags.CLOSURE)) {
-          signature = new Signature(this.program, [], Type.i32)
-          flow.locals = local.type.locals!;
-
           indexArg = module.block(null, [
             this.injectClosedLocals(
               this.module.local_get(local.index, this.options.nativeSizeType),
               local.type
             ),
             module.global_set(
               BuiltinNames.global_closure,
-              this.module.local_get(local.index, NativeType.I32)
+              this.module.local_get(local.index, this.options.nativeSizeType)
             ),
             module.load(
-              4,
+              local.type.byteSize,
               local.type.is(TypeFlags.SIGNED),
-              this.module.local_get(local.index, NativeType.I32),
-              NativeType.I32,
+              this.module.local_get(local.index, this.options.nativeSizeType),
+              this.options.nativeSizeType,
               0
             )
-          ], NativeType.I32);
+          ], this.options.nativeSizeType);
           break;
         }
-        signature = local.type.signatureReference;
         if (signature) {
           if (local.is(CommonFlags.INLINED)) {
             indexArg = module.i32(i64_low(local.constantIntegerValue));
           } else {
             indexArg = module.local_get(local.index, NativeType.I32);
           }
+          // If the 16 is divisible by 16, then it must be a closure, so we call it as such
           indexArg = module.if(
             module.binary(
               BinaryOp.EqI32,
@@ -6496,14 +6495,14 @@ export class Compiler extends DiagnosticEmitter {
                 BuiltinNames.global_closure,
                 indexArg
               ),
-              module.load(
+              module.load( //TODO: support 8 byte addrs
                 4,
                 true,
                 indexArg,
                 NativeType.I32,
                 0
               )
-            ], NativeType.I32),
+            ], this.options.nativeSizeType),
             indexArg
           )
           break;
@@ -6607,32 +6606,15 @@ export class Compiler extends DiagnosticEmitter {
         return module.unreachable();
       }
     }
-    var callExpr = this.compileCallIndirect(
+
+    return this.compileCallIndirect(
       assert(signature), // FIXME: asc can't see this yet
       indexArg,
       expression.arguments,
       expression,
       0,
       contextualType == Type.void
     );
-
-    //Closure write-back
-    //if (closedLocal) {
-      //return module.block(null, [
-        //callExpr,
-        //module.local_set(
-          //closedLocal.index,
-          //module.load(
-            //1,
-            //true,
-            //this.module.global_get(BuiltinNames.global_closure, NativeType.I32),
-            //NativeType.I32,
-            //4
-          //)
-        //)
-      //], NativeType.I32)
-    //}
-    return callExpr;
   }
 
   private compileCallExpressionBuiltin(
@@ -7129,7 +7111,6 @@ export class Compiler extends DiagnosticEmitter {
     var module = this.module;
     var flow = this.currentFlow;
     var nativeSizeType = this.options.nativeSizeType;
-    assert(false)
     if (alreadyRetained) {
       // (t1=newExpr), __release(oldExpr), t1
       // it is important that `newExpr` evaluates before `oldExpr` is released, hence the local
@@ -7196,7 +7177,6 @@ export class Compiler extends DiagnosticEmitter {
     //
     //   callReceivingAReference((__release(t = callReturningAReference()), t))
     //
-    assert(false)
     var local = flow.getAutoreleaseLocal(type);
     if (flow.isNonnull(expr, type)) flow.setLocalFlag(local.index, LocalFlags.NONNULL);
     return this.module.local_tee(local.index, expr);
@@ -7723,8 +7703,8 @@ export class Compiler extends DiagnosticEmitter {
     var instance: Function | null;
     var contextualTypeArguments = makeMap(flow.contextualTypeArguments);
 
-   //compile according to context. this differs from a normal function in that omitted parameter
-   //and return types can be inferred and omitted arguments can be replaced with dummies.
+    // compile according to context. this differs from a normal function in that omitted parameter
+    // and return types can be inferred and omitted arguments can be replaced with dummies.
     if (contextualSignature) {
       let signatureNode = prototype.functionTypeNode;
       let parameterNodes = signatureNode.parameters;
@@ -7833,28 +7813,36 @@ export class Compiler extends DiagnosticEmitter {
     }
 
     var index = this.ensureFunctionTableEntry(instance); // reports
-    console.log("function index" + index)
 
     if(index < 0) return this.module.unreachable();
 
     if(instance.closedLocals.size > 0) {
+      //Create field declarations for the function and each closed local
       var members = Array<DeclarationStatement>(instance.closedLocals.size + 1);
       members[0] = this.program.makeNativeMember("__functionPtr", "u32")
       for (let _values = Map_values(instance.closedLocals), i = 0, k = _values.length; i < k; ++i) {
         let local = unchecked(_values[i]);
-        members[i + 1] = this.program.makeNativeMember(local.name, "i32") //todo, support non-i32
+        members[i + 1] = this.program.makeNativeMember(local.name, local.type.intType.toString())
       }
 
-      var closureClassPrototype = this.program.makeNativeClassPrototype(
-        "closure|" + actualFunction.nextAnonymousId.toString(),
+      //Create a native class prototype with a dummy syntax tree, similar to native functions
+      var closureClassPrototype = assert(this.program.makeNativeClassPrototype(
+        "closure|" + this.program.nextClassId.toString(),
         members
-      )!;
+      ));
+
+      //Resolve this prototype to get the class
       var closureClass = this.resolver.resolveClass(closureClassPrototype, null)!;
+
+      //Compile this class to get the type
       this.compileClass(closureClass);
-      //set the current type to be the generated type
-      this.currentType = closureClass.type.asClosure(instance.signature)//generatedClosureType;
-      //create local to hold closure
+
+      //Append the appropriate signature and flags for this closure type, then set it to currentType
+      this.currentType = closureClass.type.asClosure(instance.signature)
+
+      //create a local which will hold our closure class instance
       var tempLocal = flow.getTempLocal(this.currentType);
+
       //copied closed locals into type
       this.currentType.locals = instance.closedLocals;
 
@@ -8125,13 +8113,19 @@ export class Compiler extends DiagnosticEmitter {
       case ElementKind.CLOSEDLOCAL: {
         let closedLocal = <ClosedLocal>target;
 
-        return module.load(
-          4,
+        // TODO: replace this with a class field access, once we are able to construct the class before
+        // compiling
+        let loadExpr = module.load(
+          closedLocal.type.byteSize,
           true,
           this.module.global_get(BuiltinNames.global_closure, NativeType.I32),
-          NativeType.I32,
-          flow.actualFunction.closedLocals.size * 4
+          closedLocal.type.toNativeType(),
+          flow.actualFunction.nextGlobalClosureOffset
         );
+
+        flow.actualFunction.nextGlobalClosureOffset += closedLocal.type.byteSize;
+
+        return loadExpr
       }
     }
     this.error(
@@ -9452,7 +9446,6 @@ export class Compiler extends DiagnosticEmitter {
         break;
       }
       default: {
-        assert(false);
         return module.unreachable();
       }
     }

src/flow.ts

@@ -204,7 +204,6 @@ export class Flow {
   inlineFunction: Function | null;
   /** The label we break to when encountering a return statement, when inlining. */
   inlineReturnLabel: string | null;
-  locals: Map<string, Local> | null;
 
   /** Creates the parent flow of the specified function. */
   static create(parentFunction: Function): Flow {
@@ -219,7 +218,6 @@ export class Flow {
     flow.localFlags = [];
     flow.inlineFunction = null;
     flow.inlineReturnLabel = null;
-    flow.locals = null;
     return flow;
   }