Removed class generation

Author: DuncanUszkay1

src/compiler.ts

@@ -6431,7 +6431,6 @@ export class Compiler extends DiagnosticEmitter {
     let _values = Map_values(locals);
     var exprs = new Array<ExpressionRef>(_values.length);
     assert(type.is(TypeFlags.REFERENCE));
-    var closureClass = assert(type.classReference);
     for (let i = 0, k = _values.length; i < k; ++i) {
       let local = unchecked(_values[i]);
       let nativeType = local.type.toNativeType();
@@ -6440,7 +6439,7 @@ export class Compiler extends DiagnosticEmitter {
         module.local_get(closureContextLocal.index, this.options.nativeSizeType),
         module.local_get(local.index, nativeType),
         nativeType,
-        closureClass.offsetof(local.name)
+        assert(local.closureContextOffset)
       );
     }
     return module.block(null, exprs);
@@ -8208,28 +8207,9 @@ export class Compiler extends DiagnosticEmitter {
     var wasm64 = nativeUsize == NativeType.I64;
 
     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", usize.toString())
-      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, local.type.intType.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 = assert(this.resolver.resolveClass(closureClassPrototype, null));
-
-      // Compile this class to get the type
-      this.compileClass(closureClass);
-
       // Append the appropriate signature and flags for this closure type, then set it to currentType
-      this.currentType = closureClass.type.asClosure(instance.signature)
+      this.currentType = Type.closure32;
+      this.currentType.signatureReference = instance.signature;
 
       // create a local which will hold our closure class instance
       var tempLocal = flow.getAutoreleaseLocal(this.currentType);
@@ -8238,14 +8218,15 @@ export class Compiler extends DiagnosticEmitter {
       // copied closed locals into type
       this.currentType.locals = instance.closedLocals;
 
+      const closureSize = instance.nextGlobalClosureOffset
 
       var closureExpr = this.module.flatten([
         this.module.local_set( // Allocate memory for the closure
           tempLocalIndex,
           this.makeRetain(
             this.module.call(this.program.allocInstance.internalName, [
-              wasm64 ? this.module.i64(closureClass.type.byteSize) : this.module.i32(closureClass.type.byteSize),
-              wasm64 ? this.module.i64(closureClass.id) : this.module.i32(closureClass.id)
+              wasm64 ? this.module.i64(closureSize) : this.module.i32(closureSize),
+              wasm64 ? this.module.i64(0) : this.module.i32(0)
             ], nativeUsize)
           )
         ),

src/program.ts

@@ -671,48 +671,6 @@ export class Program extends DiagnosticEmitter {
     );
   }
 
-  // TODO: make these more generic, purpose built for closures atm
-  makeNativeMember(
-    name: string,
-    type: string
-  ): DeclarationStatement {
-    return Node.createFieldDeclaration(
-      Node.createIdentifierExpression(name, this.nativeSource.range),
-      Node.createNamedType(
-        Node.createSimpleTypeName(type, this.nativeSource.range),
-        null,
-        false,
-        this.nativeSource.range,
-      ),
-      null,
-      null,
-      CommonFlags.INSTANCE,
-      this.nativeSource.range
-    );
-  }
-
-  makeNativeClassDeclaration(name: string, members: DeclarationStatement[]): ClassDeclaration {
-    return Node.createClassDeclaration(
-      Node.createIdentifierExpression(name, this.nativeSource.range),
-      null,
-      null,
-      null,
-      members,
-      null,
-      0,
-      this.nativeSource.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;

src/types.ts

@@ -185,7 +185,7 @@ export class Type {
   }
 
   get isFunction(): bool {
-    return this.signatureReference !== null && this.classReference === null;
+    return this.signatureReference !== null && !this.is(TypeFlags.CLOSURE);
   }
 
   /** Computes the sign-extending shift in the target type. */
@@ -535,6 +535,13 @@ export class Type {
 
   /** Alias of i32 indicating type inference of locals and globals with just an initializer. */
   static readonly auto: Type = new Type(Type.i32.kind, Type.i32.flags, Type.i32.size);
+
+  /** Type of an in-context local */
+  static readonly closure32: Type = new Type(Type.i32.kind,
+    TypeFlags.CLOSURE |
+    TypeFlags.REFERENCE,
+    Type.i32.size
+  );
 }
 
 /** Converts an array of types to an array of native types. */