Add Closures

Author: DuncanUszkay1

src/common.ts

@@ -71,7 +71,7 @@ export enum CommonFlags {
   /** Is a virtual method. */
   VIRTUAL = 1 << 26,
   /** Is (part of) a closure. */
-  CLOSURE = 1 << 27,
+  IN_SCOPE_CLOSURE = 1 << 27,
 
   // Other
 

src/compiler.ts

@@ -3275,7 +3275,9 @@ export class Local extends VariableLikeElement {
     /** Parent function. */
     parent: Function,
     /** Declaration reference. */
-    declaration: VariableLikeDeclarationStatement = parent.program.makeNativeVariableDeclaration(name)
+    declaration: VariableLikeDeclarationStatement = parent.program.makeNativeVariableDeclaration(name),
+    /** Offset of this variable within closure context, if it's value is held there */
+    public closureContextOffset: usize | null = null,
   ) {
     super(
       ElementKind.LOCAL,
@@ -3286,6 +3288,18 @@ export class Local extends VariableLikeElement {
     this.index = index;
     assert(type != Type.void);
     this.setType(type);
+    this.closureContextOffset = closureContextOffset;
+  }
+
+  close(offset: usize): Local {
+    return new Local(
+      this.name,
+      this.index,
+      this.type,
+      <Function>this.parent,
+      <VariableLikeDeclarationStatement>this.declaration,
+      offset
+    );
   }
 }
 
@@ -3354,6 +3368,11 @@ export class FunctionPrototype extends DeclaredElement {
            );
   }
 
+  get hasNestedDefinition(): bool {
+    var parent = this.parent;
+    return parent.kind == ElementKind.FUNCTION;
+  }
+
   /** Creates a clone of this prototype that is bound to a concrete class instead. */
   toBound(classInstance: Class): FunctionPrototype {
     assert(this.is(CommonFlags.INSTANCE));
@@ -3413,6 +3432,12 @@ export class Function extends TypedElement {
   additionalLocals: Type[] = [];
   /** Concrete type arguments. */
   typeArguments: Type[] | null;
+  /** List of all closed locals discovered so far */
+  closedLocals: Map<string, Local> = new Map();
+  /** Next global closure offset to use, assuming that classes are packed as c-structs in the order given */
+  /** This is temporary- once we have a ScopeAnalyzer, then the closure class will be defined before we */
+  /** start compiling, and we can just insert a field access */
+  nextGlobalClosureOffset: u32 = 4;
   /** Contextual type arguments. */
   contextualTypeArguments: Map<string,Type> | null;
   /** Default control flow. */
@@ -3466,11 +3491,11 @@ export class Function extends TypedElement {
     this.type = program.options.usizeType.asFunction(signature);
     if (!prototype.is(CommonFlags.AMBIENT)) {
       let localIndex = 0;
-      if (this.is(CommonFlags.INSTANCE)) {
+      if (signature.thisType !== null) {
         let local = new Local(
           CommonNames.this_,
           localIndex++,
-          assert(signature.thisType),
+          signature.thisType,
           this
         );
         this.localsByName.set(CommonNames.this_, local);
@@ -3536,6 +3561,29 @@ export class Function extends TypedElement {
   lookup(name: string): Element | null {
     var locals = this.localsByName;
     if (locals.has(name)) return assert(locals.get(name));
+    if (this.parent.kind == ElementKind.FUNCTION) {
+      var parentFunction = <Function>this.parent;
+      var parentResult = parentFunction.flow.lookup(name);
+      if (parentResult === null) return null;
+      if (parentFunction.closedLocals.size > 0) { //TODO allow nested closure definitions
+        this.program.error(
+          DiagnosticCode.Not_implemented,
+          this.identifierNode.range, this.identifierNode.text
+        );
+        return null;
+      }
+      if (parentResult.kind == ElementKind.LOCAL) {
+        let local = changetype<Local>(parentResult);
+        if (this.closedLocals.has(local.name)) return assert(this.closedLocals.get(local.name));
+        let mask = local.type.byteSize - 1;
+        let memoryOffset = this.nextGlobalClosureOffset;
+        if (memoryOffset & mask) memoryOffset = (memoryOffset | mask) + 1;
+        var closedLocal = local.close(memoryOffset);
+        this.nextGlobalClosureOffset = memoryOffset + local.type.byteSize;
+        this.closedLocals.set(local.name, closedLocal);
+        return closedLocal;
+      }
+    }
     return this.parent.lookup(name);
   }
 

src/program.ts

@@ -2774,6 +2774,7 @@ export class Resolver extends DiagnosticEmitter {
     var signature = new Signature(this.program, parameterTypes, returnType, thisType);
     signature.parameterNames = parameterNames;
     signature.requiredParameters = requiredParameters;
+    if (prototype.hasNestedDefinition) signature = signature.toClosureSignature();
 
     var nameInclTypeParameters = prototype.name;
     if (instanceKey.length) nameInclTypeParameters += "<" + instanceKey + ">";

src/resolver.ts

@@ -7,7 +7,8 @@ import {
   Class,
   FunctionTarget,
   Program,
-  DecoratorFlags
+  DecoratorFlags,
+  Local
 } from "./program";
 
 import {
@@ -95,7 +96,9 @@ export const enum TypeFlags {
   /** Is a vector type. */
   VECTOR = 1 << 10,
   /** Is a host type. */
-  HOST = 1 << 11
+  HOST = 1 << 11,
+  /** Is a closure type. */
+  IN_SCOPE_CLOSURE = 1 << 12
 }
 
 /** Represents a resolved type. */
@@ -113,6 +116,8 @@ export class Type {
   classReference: Class | null;
   /** Underlying signature reference, if a function type. */
   signatureReference: Signature | null;
+  /** closed over locals */
+  locals: Map<string, Local> | null;
   /** Respective non-nullable type, if nullable. */
   nonNullableType: Type;
   /** Cached nullable type, if non-nullable. */
@@ -127,6 +132,7 @@ export class Type {
     this.classReference = null;
     this.signatureReference = null;
     this.nonNullableType = this;
+    this.locals = null;
   }
 
   /** Returns the closest int type representing this type. */
@@ -163,6 +169,7 @@ export class Type {
 
   /** Tests if this is a managed type that needs GC hooks. */
   get isManaged(): bool {
+    if (this.isFunctionIndex) return true;
     if (this.is(TypeFlags.INTEGER | TypeFlags.REFERENCE)) {
       let classReference = this.classReference;
       if (classReference) return !classReference.hasDecorator(DecoratorFlags.UNMANAGED);
@@ -177,6 +184,10 @@ export class Type {
     return classReference !== null && classReference.hasDecorator(DecoratorFlags.UNMANAGED);
   }
 
+  get isFunctionIndex(): bool {
+    return this.signatureReference !== null && !this.is(TypeFlags.IN_SCOPE_CLOSURE);
+  }
+
   /** Computes the sign-extending shift in the target type. */
   computeSmallIntegerShift(targetType: Type): i32 {
     return targetType.size - this.size;
@@ -517,6 +528,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.IN_SCOPE_CLOSURE |
+    TypeFlags.REFERENCE,
+    Type.i32.size
+  );
 }
 
 /** Converts an array of types to an array of native types. */
@@ -626,18 +644,8 @@ export class Signature {
       : getDefaultParameterName(index);
   }
 
-  /** Tests if this signature equals the specified. */
-  equals(other: Signature): bool {
-
-    // check `this` type
-    var thisThisType = this.thisType;
-    var otherThisType = other.thisType;
-    if (thisThisType !== null) {
-      if (otherThisType === null || !thisThisType.equals(otherThisType)) return false;
-    } else if (otherThisType) {
-      return false;
-    }
-
+  // Check to see if this signature is equivalent to the caller, ignoring the this type
+  externalEquals(other: Signature): bool {
     // check rest parameter
     if (this.hasRest != other.hasRest) return false;
 
@@ -654,6 +662,20 @@ export class Signature {
     return this.returnType.equals(other.returnType);
   }
 
+  /** Tests if this signature equals the specified. */
+  equals(other: Signature): bool {
+    // check `this` type
+    var thisThisType = this.thisType;
+    var otherThisType = other.thisType;
+    if (thisThisType !== null) {
+      if (otherThisType === null || !thisThisType.equals(otherThisType)) return false;
+    } else if (otherThisType !== null) {
+      return false;
+    }
+
+    return this.externalEquals(other);
+  }
+
   /** Tests if a value of this function type is assignable to a target of the specified function type. */
   isAssignableTo(target: Signature, requireSameSize: bool = false): bool {
 
@@ -720,6 +742,20 @@ export class Signature {
     return sb.join("");
   }
 
+  toClosureSignature(): Signature {
+    var closureSignature = this.clone();
+    closureSignature.thisType = this.program.options.usizeType;
+    return closureSignature;
+  }
+
+  // Reverses toClosureSignature, for when we recompile a function with the context argument
+  // Not convinced this is the right way to go about getting the original unmodified signature, but it works
+  toAnonymousSignature(): Signature {
+    var normalSignature = this.clone();
+    normalSignature.thisType = null;
+    return normalSignature;
+  }
+
   /** Creates a clone of this signature that is safe to modify. */
   clone(): Signature {
     var parameterTypes = this.parameterTypes;
@@ -738,6 +774,7 @@ export class Signature {
       }
       clone.parameterNames = cloneParameterNames;
     }
+    clone.requiredParameters = this.requiredParameters;
     return clone;
   }
 }