temp

Author: DuncanUszkay1

src/compiler.ts

@@ -3465,16 +3465,7 @@ export class Compiler extends DiagnosticEmitter {
         fromType = fromType.nonNullableType;
       }
       if(fromType.is(TypeFlags.CLOSURE)) {
-        return module.block(null, [
-          module.store(
-            1,
-            expr,
-            this.module.local_get(fromType.locals![0].index, this.options.nativeSizeType),
-            NativeType.I32,
-            4
-          ),
-          expr
-        ], NativeType.I32)
+        return module.block(null, [this.injectClosedLocals(expr, fromType), expr], NativeType.I32)
       }
       if (fromType.isAssignableTo(toType)) { // downcast or same
         assert(fromType.kind == toType.kind);
@@ -6335,6 +6326,27 @@ export class Compiler extends DiagnosticEmitter {
     }
   }
 
+  private injectClosedLocals(
+    expr: ExpressionRef,
+    type: Type
+  ): 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 local = unchecked(_values[i]);
+      exprs.push(module.store(
+          local.type.byteSize,
+          expr,
+          this.module.local_get(local.index, NativeType.I32),
+          NativeType.I32,
+          (i + 1) * 4
+      ))
+    }
+    //exprs.push(module.unreachable())
+    return module.block(null, exprs)
+  }
+
   /** Compiles a call expression according to the specified context. */
   private compileCallExpression(
     /** Call expression to compile. */
@@ -6417,7 +6429,6 @@ export class Compiler extends DiagnosticEmitter {
       // direct call: concrete function
       case ElementKind.FUNCTION_PROTOTYPE: {
         let functionPrototype = <FunctionPrototype>target;
-
         // builtins handle present respectively omitted type arguments on their own
         if (functionPrototype.hasDecorator(DecoratorFlags.BUILTIN)) {
           return this.compileCallExpressionBuiltin(functionPrototype, expression, contextualType);
@@ -6442,23 +6453,20 @@ export class Compiler extends DiagnosticEmitter {
         let local = <Local>target;
         if(local.type.is(TypeFlags.CLOSURE)) {
           signature = new Signature(this.program, [], Type.i32)
-          var closedLocals = local.type.locals!;
-          console.log(closedLocals)
+          flow.locals = local.type.locals!;
+
           indexArg = module.block(null, [
-            module.store(
-              1,
+            this.injectClosedLocals(
               this.module.local_get(local.index, this.options.nativeSizeType),
-              this.module.local_get(closedLocals[0].index, NativeType.I32),
-              NativeType.I32,
-              4
+              local.type
             ),
             module.global_set(
               BuiltinNames.global_closure,
               this.module.local_get(local.index, NativeType.I32)
             ),
             module.load(
-              1,
-              true,
+              4,
+              local.type.is(TypeFlags.SIGNED),
               this.module.local_get(local.index, NativeType.I32),
               NativeType.I32,
               0
@@ -6489,7 +6497,7 @@ export class Compiler extends DiagnosticEmitter {
                 indexArg
               ),
               module.load(
-                1,
+                4,
                 true,
                 indexArg,
                 NativeType.I32,
@@ -7715,81 +7723,6 @@ export class Compiler extends DiagnosticEmitter {
     var instance: Function | null;
     var contextualTypeArguments = makeMap(flow.contextualTypeArguments);
 
-    if(prototype.name.startsWith("anonymous")) {
-      console.log("compiling " + prototype.name + " as a closure")
-      let generatedClosureType = new Type(
-        TypeKind.U32,
-        TypeFlags.CLOSURE | TypeFlags.REFERENCE | TypeFlags.POINTER, //flags
-        64
-      )
-
-      this.currentType = generatedClosureType;
-
-      assert(!contextualSignature)
-
-      instance = this.resolver.resolveFunction(prototype, null, contextualTypeArguments);
-      if (!instance) return this.module.unreachable();
-      this.compileFunction(instance);
-      //this.currentType = instance.signature.type;
-
-      //create function
-      var index = this.ensureFunctionTableEntry(instance!); // reports
-      console.log("closure " + prototype.name + " was assigned func table entry " + index.toString())
-
-      var closedLocals = instance.closedLocals
-
-
-      var names = ["fn","scopeI32"];
-      var numNames = names.length;
-      var values = [
-        this.module.i32(index),
-        this.module.local_get(closedLocals[0].index, NativeType.I32)
-      ];
-      var exprs = new Array<ExpressionRef>(numNames + 2);
-      var flow = this.currentFlow;
-      //var tempLocal = flow.getAutoreleaseLocal(generatedClosureType);
-      var tempLocal = flow.getTempLocal(generatedClosureType);
-
-      generatedClosureType.locals = closedLocals;
-
-      for (let i = 0, k = numNames; i < k; ++i) {
-        exprs[i + 1] = this.module.store( // TODO: handle setters as well
-          1,
-          this.module.local_get(tempLocal.index, this.options.nativeSizeType),
-          values[i],
-          NativeType.I32,
-          i * 4
-        );
-      }
-      //this.currentType = classReference.type.nonNullableType;
-      this.currentType = generatedClosureType;
-
-      // allocate a new instance first and assign 'this' to the temp. local
-      exprs[0] = this.module.local_set(
-        tempLocal.index,
-        this.module.call(this.program.allocInstance.internalName, [
-          this.module.i32(2),
-          this.module.i32(0)
-        ], NativeType.I32)
-      );
-
-      //Set closure global
-      //exprs[exprs.length - 2] = this.module.global_set(
-        //BuiltinNames.global_closure,
-        //this.module.local_get(tempLocal.index, NativeType.I32)
-      //)
-      //exprs[exprs.length - 2] = this.module.global_set("GLOBAL_CLOSURE", this.module.i32(1))
-
-      // once all field values have been set, return 'this'
-      exprs[exprs.length - 1] = this.module.local_get(tempLocal.index, this.options.nativeSizeType);
-
-      return this.module.flatten(exprs, this.options.nativeSizeType);
-
-      //return index < 0
-        //? this.module.unreachable()
-        //: this.module.i32(index);
-    }
-
    //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) {
@@ -7900,9 +7833,51 @@ export class Compiler extends DiagnosticEmitter {
     }
 
     var index = this.ensureFunctionTableEntry(instance); // reports
-    return index < 0
-      ? this.module.unreachable()
-      : this.module.i32(index);
+    console.log("function index" + index)
+
+    if(index < 0) return this.module.unreachable();
+
+    if(instance.closedLocals.size > 0) {
+      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
+      }
+
+      var closureClassPrototype = this.program.makeNativeClassPrototype(
+        "closure|" + actualFunction.nextAnonymousId.toString(),
+        members
+      )!;
+      var closureClass = this.resolver.resolveClass(closureClassPrototype, null)!;
+      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
+      var tempLocal = flow.getTempLocal(this.currentType);
+      //copied closed locals into type
+      this.currentType.locals = instance.closedLocals;
+
+      return this.module.flatten([
+        this.module.local_set( //Allocate memory for the closure
+          tempLocal.index,
+          this.module.call(this.program.allocInstance.internalName, [
+            this.module.i32(closureClass.type.byteSize),
+            this.module.i32(closureClass.id)
+          ], NativeType.I32)
+        ),
+        this.module.store( //Store the function pointer at the first index
+          4,
+          this.module.local_get(tempLocal.index, this.options.nativeSizeType),
+          this.module.i32(index),
+          NativeType.I32,
+          0
+        ),
+        this.module.local_get(tempLocal.index, this.options.nativeSizeType) //load the closure locals index
+      ], this.options.nativeSizeType);
+    }
+
+    return this.module.i32(index);
   }
 
   /** Makes sure the enclosing source file of the specified expression has been compiled. */
@@ -8151,11 +8126,11 @@ export class Compiler extends DiagnosticEmitter {
         let closedLocal = <ClosedLocal>target;
 
         return module.load(
-          1,
+          4,
           true,
           this.module.global_get(BuiltinNames.global_closure, NativeType.I32),
           NativeType.I32,
-          4
+          flow.actualFunction.closedLocals.size * 4
         );
       }
     }

src/flow.ts

@@ -204,6 +204,7 @@ 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 {
@@ -218,6 +219,7 @@ export class Flow {
     flow.localFlags = [];
     flow.inlineFunction = null;
     flow.inlineReturnLabel = null;
+    flow.locals = null;
     return flow;
   }
 
@@ -505,9 +507,6 @@ export class Flow {
 
   /** Sets the specified flag or flags on the local at the specified index. */
   setLocalFlag(index: i32, flag: LocalFlags): void {
-    if(flag == LocalFlags.RETAINED) {
-      assert(false)
-    }
     if (index < 0) return;
     var localFlags = this.localFlags;
     var flags = index < localFlags.length ? unchecked(localFlags[index]) : 0;

src/program.ts

@@ -670,6 +670,47 @@ export class Program extends DiagnosticEmitter {
     );
   }
 
+  makeNativeMember(
+    name: string,
+    type: string
+  ): DeclarationStatement {
+    return Node.createFieldDeclaration(
+      Node.createIdentifierExpression(name, this.nativeSource.range), //name: IdentifierExpression,
+      Node.createNamedType(
+        Node.createSimpleTypeName(type, this.nativeSource.range), //name: TypeName,
+        null,//typeArguments: TypeNode[] | null,
+        false,//isNullable: bool,
+        this.nativeSource.range,//range: Range
+      ), //type: TypeNode | null,
+      null,//initializer: Expression | null,
+      null,//decorators: DecoratorNode[] | null,
+      CommonFlags.INSTANCE,//flags: CommonFlags,
+      this.nativeSource.range//range: Range
+    )
+  }
+
+  makeNativeClassDeclaration(name: string, members: DeclarationStatement[]): ClassDeclaration {
+    return Node.createClassDeclaration(
+      Node.createIdentifierExpression(name, this.nativeSource.range), //identifier: IdentifierExpression,
+      null,//typeParameters: TypeParameterNode[] | null,
+      null,//extendsType: NamedTypeNode | null, // can't be a function
+      null,//implementsTypes: NamedTypeNode[] | null, // can't be functions
+      members,//members: DeclarationStatement[],
+      null,//decorators: DecoratorNode[] | null,
+      0,//flags: CommonFlags,
+      this.nativeSource.range//range: Range
+    )
+  }
+
+  makeNativeClassPrototype(name: string, members: DeclarationStatement[]): ClassPrototype | null {
+    return this.initializeClass(
+      this.makeNativeClassDeclaration(name, members),
+      this.nativeFile,
+      [],
+      []
+    )
+  }
+
   /** Gets the (possibly merged) program element linked to the specified declaration. */
   getElementByDeclaration(declaration: DeclarationStatement): DeclaredElement | null {
     var elementsByDeclaration = this.elementsByDeclaration;
@@ -950,6 +991,7 @@ export class Program extends DiagnosticEmitter {
     //this.closureInstance = this.requireClass("Closure");
     //assert(this.closureInstance.id == 3);
 
+
     // register classes backing basic types
     this.registerWrapperClass(Type.i8, CommonNames.I8);
     this.registerWrapperClass(Type.i16, CommonNames.I16);
@@ -2876,6 +2918,7 @@ export class ClosedLocal extends VariableLikeElement {
       local,
       <VariableLikeDeclarationStatement>local.declaration
     );
+    this.type = local.type;
   }
 }
 
@@ -2995,7 +3038,7 @@ export class Function extends TypedElement {
   localsByIndex: Local[] = [];
   /** List of additional non-parameter locals. */
   additionalLocals: Type[] = [];
-  closedLocals: Local[] = [];
+  closedLocals: Map<string, Local> = new Map();
   /** Contextual type arguments. */
   contextualTypeArguments: Map<string,Type> | null;
   /** Default control flow. */
@@ -3104,7 +3147,7 @@ export class Function extends TypedElement {
     var parentResult = this.parent.lookup(name);
     if(parentResult && this.parent.kind == ElementKind.FUNCTION) {
       let local = changetype<Local>(parentResult)
-      this.closedLocals.push(local)
+      this.closedLocals.set(local.name, local)
       return local.close()
     }
     return parentResult;
@@ -3952,7 +3995,7 @@ export class Interface extends Class { // FIXME
 
 /** Registers a concrete element with a program. */
 function registerConcreteElement(program: Program, element: Element): void {
-  assert(!program.instancesByName.has(element.internalName));
+  //assert(!program.instancesByName.has(element.internalName));
   program.instancesByName.set(element.internalName, element);
 }