Add support for interfaces extending multiple interfaces

This is a feature in TypeScript, and I didn't see much of a technical
reason to disallow it. By changing interface extension such that
implementsTypes and interfacePrototypes are used for base interfaces
instead of extendsType and basePrototype in InterfacePrototype and
Interface respectively, and by modifying the parser, existing code
doesn't seem to break, and multiple base interfaces are possible (if not
working already).

There was also a small change to the instanceof helper generation, where
arrays are now used instead of Sets, since I needed to filter for
interfaces, and Set_values was used on the constructed Set regardless.
However, the change also modified the order of instanceof checks as seen
in instanceof.debug.wat. The instanceof.release.wat file underwent more
drastic changes, but thanks to the previous commit, it still appears to
work anyway.

Author: CountBleck

src/compiler.ts

@@ -7683,23 +7683,26 @@ export class Compiler extends DiagnosticEmitter {
         ), false // managedness is irrelevant here, isn't interrupted
       )
     );
-    let allInstances: Set<Class> | null;
+    let allInstances: Class[] | null;
     if (instance.isInterface) {
-      allInstances = instance.implementers;
+      let implementers = instance.implementers;
+      // Ensure interfaces are filtered out, since their class IDs will never be
+      // seen in actual objects.
+      allInstances = implementers
+        ? Set_values(implementers).filter(implementer => implementer.kind == ElementKind.Class)
+        : null;
     } else {
-      allInstances = new Set();
-      allInstances.add(instance);
       let extenders = instance.extenders;
       if (extenders) {
-        for (let _values = Set_values(extenders), i = 0, k = _values.length; i < k; ++i) {
-          let extender = _values[i];
-          allInstances.add(extender);
-        }
+        allInstances = Set_values(extenders);
+        allInstances.push(instance);
+      } else {
+        allInstances = [instance];
       }
     }
     if (allInstances) {
-      for (let _values = Set_values(allInstances), i = 0, k = _values.length; i < k; ++i) {
-        let instance = _values[i];
+      for (let i = 0, k = allInstances.length; i < k; ++i) {
+        let instance = unchecked(allInstances[i]);
         stmts.push(
           module.br("is_instance",
             module.binary(BinaryOp.EqI32,

src/extra/ast.ts

@@ -1297,12 +1297,16 @@ export class ASTBuilder {
       }
       sb.push(">");
     }
-    let extendsType = node.extendsType;
-    if (extendsType) {
+    let implementsTypes = node.implementsTypes;
+    if (implementsTypes && implementsTypes.length > 0) {
       sb.push(" extends ");
-      this.visitTypeNode(extendsType);
+      this.visitTypeNode(implementsTypes[0]);
+      for (let i = 1, k = implementsTypes.length; i < k; ++i) {
+        sb.push(", ");
+        this.visitTypeNode(implementsTypes[i]);
+      }
     }
-    // must not have implementsTypes
+    // must not have extendsType
     sb.push(" {\n");
     let indentLevel = ++this.indentLevel;
     let members = node.members;

src/parser.ts

@@ -1703,20 +1703,40 @@ export class Parser extends DiagnosticEmitter {
     }
 
     let extendsType: NamedTypeNode | null = null;
+    let implementsTypes: NamedTypeNode[] | null = null;
     if (tn.skip(Token.Extends)) {
-      let type = this.parseType(tn);
-      if (!type) return null;
-      if (type.kind != NodeKind.NamedType) {
-        this.error(
-          DiagnosticCode.Identifier_expected,
-          type.range
-        );
-        return null;
+      if (isInterface) {
+        do {
+          let type = this.parseType(tn);
+          if (!type) return null;
+          if (type.kind != NodeKind.NamedType) {
+            this.error(
+              DiagnosticCode.Identifier_expected,
+              type.range
+            );
+            return null;
+          }
+          // Note: Even though the keyword is "extends", the base interfaces are stored in
+          //       the implementsTypes field, as that's already an array that can be used.
+          //       When an InterfacePrototype is created, the base InterfacePrototypes are
+          //       stored in the interfacePrototypes field for the same reason.
+          if (!implementsTypes) implementsTypes = [<NamedTypeNode>type];
+          else implementsTypes.push(<NamedTypeNode>type);
+        } while (tn.skip(Token.Comma));
+      } else {
+        let type = this.parseType(tn);
+        if (!type) return null;
+        if (type.kind != NodeKind.NamedType) {
+          this.error(
+            DiagnosticCode.Identifier_expected,
+            type.range
+          );
+          return null;
+        }
+        extendsType = <NamedTypeNode>type;
       }
-      extendsType = <NamedTypeNode>type;
     }
 
-    let implementsTypes: NamedTypeNode[] | null = null;
     if (tn.skip(Token.Implements)) {
       if (isInterface) {
         this.error(
@@ -1752,14 +1772,14 @@ export class Parser extends DiagnosticEmitter {
     let members = new Array<DeclarationStatement>();
     let declaration: ClassDeclaration;
     if (isInterface) {
-      assert(!implementsTypes);
+      assert(!extendsType);
       declaration = Node.createInterfaceDeclaration(
         identifier,
         decorators,
         flags,
         typeParameters,
-        extendsType,
         null,
+        implementsTypes,
         members,
         tn.range(startPos, tn.pos)
       );

src/program.ts

@@ -1129,7 +1129,7 @@ export class Program extends DiagnosticEmitter {
             break;
           }
           case NodeKind.InterfaceDeclaration: {
-            this.initializeInterface(<InterfaceDeclaration>statement, file, queuedExtends);
+            this.initializeInterface(<InterfaceDeclaration>statement, file, queuedImplements);
             break;
           }
           case NodeKind.NamespaceDeclaration: {
@@ -1302,64 +1302,45 @@ export class Program extends DiagnosticEmitter {
       }
     }
 
-    // resolve prototypes of extended classes or interfaces
+    // resolve prototypes of extended classes
     let resolver = this.resolver;
     for (let i = 0, k = queuedExtends.length; i < k; ++i) {
       let thisPrototype = queuedExtends[i];
+      assert(thisPrototype.kind == ElementKind.ClassPrototype);
       let extendsNode = assert(thisPrototype.extendsNode); // must be present if in queuedExtends
       let baseElement = resolver.resolveTypeName(extendsNode.name, thisPrototype.parent);
       if (!baseElement) continue;
-      if (thisPrototype.kind == ElementKind.ClassPrototype) {
-        if (baseElement.kind == ElementKind.ClassPrototype) {
-          let basePrototype = <ClassPrototype>baseElement;
-          if (basePrototype.hasDecorator(DecoratorFlags.Final)) {
-            this.error(
-              DiagnosticCode.Class_0_is_final_and_cannot_be_extended,
-              extendsNode.range, basePrototype.identifierNode.text
-            );
-          }
-          if (
-            basePrototype.hasDecorator(DecoratorFlags.Unmanaged) !=
-            thisPrototype.hasDecorator(DecoratorFlags.Unmanaged)
-          ) {
-            this.error(
-              DiagnosticCode.Unmanaged_classes_cannot_extend_managed_classes_and_vice_versa,
-              Range.join(thisPrototype.identifierNode.range, extendsNode.range)
-            );
-          }
-          if (!thisPrototype.extends(basePrototype)) {
-            thisPrototype.basePrototype = basePrototype;
-          } else {
-            this.error(
-              DiagnosticCode._0_is_referenced_directly_or_indirectly_in_its_own_base_expression,
-              basePrototype.identifierNode.range,
-              basePrototype.identifierNode.text,
-            );
-          }
-        } else {
+      if (baseElement.kind == ElementKind.ClassPrototype) {
+        let basePrototype = <ClassPrototype>baseElement;
+        if (basePrototype.hasDecorator(DecoratorFlags.Final)) {
           this.error(
-            DiagnosticCode.A_class_may_only_extend_another_class,
-            extendsNode.range
+            DiagnosticCode.Class_0_is_final_and_cannot_be_extended,
+            extendsNode.range, basePrototype.identifierNode.text
           );
         }
-      } else if (thisPrototype.kind == ElementKind.InterfacePrototype) {
-        if (baseElement.kind == ElementKind.InterfacePrototype) {
-          const basePrototype = <InterfacePrototype>baseElement;
-          if (!thisPrototype.extends(basePrototype)) {
-            thisPrototype.basePrototype = basePrototype;
-          } else {
-            this.error(
-              DiagnosticCode._0_is_referenced_directly_or_indirectly_in_its_own_base_expression,
-              basePrototype.identifierNode.range,
-              basePrototype.identifierNode.text,
-            );
-          }
+        if (
+          basePrototype.hasDecorator(DecoratorFlags.Unmanaged) !=
+          thisPrototype.hasDecorator(DecoratorFlags.Unmanaged)
+        ) {
+          this.error(
+            DiagnosticCode.Unmanaged_classes_cannot_extend_managed_classes_and_vice_versa,
+            Range.join(thisPrototype.identifierNode.range, extendsNode.range)
+          );
+        }
+        if (!thisPrototype.extends(basePrototype)) {
+          thisPrototype.basePrototype = basePrototype;
         } else {
           this.error(
-            DiagnosticCode.An_interface_can_only_extend_an_interface,
-            extendsNode.range
+            DiagnosticCode._0_is_referenced_directly_or_indirectly_in_its_own_base_expression,
+            basePrototype.identifierNode.range,
+            basePrototype.identifierNode.text,
           );
         }
+      } else {
+        this.error(
+          DiagnosticCode.A_class_may_only_extend_another_class,
+          extendsNode.range
+        );
       }
     }
 
@@ -1398,7 +1379,7 @@ export class Program extends DiagnosticEmitter {
       }
     }
 
-    // resolve prototypes of implemented interfaces
+    // resolve prototypes of implemented/extended interfaces
     for (let i = 0, k = queuedImplements.length; i < k; ++i) {
       let thisPrototype = queuedImplements[i];
       let implementsNodes = assert(thisPrototype.implementsNodes); // must be present if in queuedImplements
@@ -1410,10 +1391,23 @@ export class Program extends DiagnosticEmitter {
           let interfacePrototype = <InterfacePrototype>interfaceElement;
           let interfacePrototypes = thisPrototype.interfacePrototypes;
           if (!interfacePrototypes) thisPrototype.interfacePrototypes = interfacePrototypes = new Array();
-          interfacePrototypes.push(interfacePrototype);
+          if (
+            thisPrototype.kind == ElementKind.Interface &&
+            thisPrototype.implements(interfacePrototype)
+          ) {
+            this.error(
+              DiagnosticCode._0_is_referenced_directly_or_indirectly_in_its_own_base_expression,
+              interfacePrototype.identifierNode.range,
+              interfacePrototype.identifierNode.text,
+            );
+          } else {
+            interfacePrototypes.push(interfacePrototype);
+          }
         } else {
           this.error(
-            DiagnosticCode.A_class_can_only_implement_an_interface,
+            thisPrototype.kind == ElementKind.InterfacePrototype
+              ? DiagnosticCode.An_interface_can_only_extend_an_interface
+              : DiagnosticCode.A_class_can_only_implement_an_interface,
             implementsNode.range
           );
         }
@@ -2473,7 +2467,7 @@ export class Program extends DiagnosticEmitter {
         break;
       }
       case NodeKind.InterfaceDeclaration: {
-        element = this.initializeInterface(<InterfaceDeclaration>declaration, parent, queuedExtends);
+        element = this.initializeInterface(<InterfaceDeclaration>declaration, parent, queuedImplements);
         break;
       }
       case NodeKind.NamespaceDeclaration: {
@@ -2624,7 +2618,7 @@ export class Program extends DiagnosticEmitter {
     /** Parent element, usually a file or namespace. */
     parent: Element,
     /** So far queued `extends` clauses. */
-    queuedExtends: ClassPrototype[],
+    queuedImplements: ClassPrototype[],
   ): InterfacePrototype | null {
     let name = declaration.name.text;
     let element = new InterfacePrototype(
@@ -2637,8 +2631,10 @@ export class Program extends DiagnosticEmitter {
     );
     if (!parent.add(name, element)) return null;
 
-    // remember interfaces that extend another interface
-    if (declaration.extendsType) queuedExtends.push(element);
+    // remember interfaces that extend other interfaces
+    // Note: See the corresponding note in parseClassOrInterface (in parser.ts) for
+    //       further information as to why implementsTypes is used.
+    if (declaration.implementsTypes) queuedImplements.push(element);
 
     let memberDeclarations = declaration.members;
     for (let i = 0, k = memberDeclarations.length; i < k; ++i) {
@@ -2757,7 +2753,7 @@ export class Program extends DiagnosticEmitter {
           break;
         }
         case NodeKind.InterfaceDeclaration: {
-          this.initializeInterface(<InterfaceDeclaration>member, original, queuedExtends);
+          this.initializeInterface(<InterfaceDeclaration>member, original, queuedImplements);
           break;
         }
         case NodeKind.NamespaceDeclaration: {
@@ -4270,6 +4266,24 @@ export class ClassPrototype extends DeclaredElement {
     return false;
   }
 
+  implements(other: InterfacePrototype, seen: Set<InterfacePrototype> | null = null): bool {
+    if (this.interfacePrototypes) {
+      if (!seen) seen = new Set();
+      let interfacePrototypes = assert(this.interfacePrototypes);
+
+      for (let i = 0, k = interfacePrototypes.length; i < k; ++i) {
+        let prototype = unchecked(interfacePrototypes[i]);
+
+        if (prototype == other) return true;
+        if (seen.has(prototype)) continue;
+        seen.add(prototype);
+
+        if (prototype.implements(other, seen)) return true;
+      }
+    }
+    return false;
+  }
+
   /** Adds an element as an instance member of this one. Returns the previous element if a duplicate. */
   addInstance(name: string, element: DeclaredElement): bool {
     let originalDeclaration = element.declaration;
@@ -4529,9 +4543,11 @@ export class Class extends TypedElement {
     // Start with the interface itself, adding this class and its extenders to
     // its implementers. Repeat for the interface's bases that are indirectly
     // implemented by means of being extended by the interface.
-    let nextIface: Interface | null = iface;
+    // TODO: Maybe add a fast path when `iface` has no bases?
+    let ifaceStack = [iface];
     let extenders = this.extenders;
     do {
+      let nextIface = assert(ifaceStack.pop());
       let implementers = nextIface.implementers;
       if (!implementers) nextIface.implementers = implementers = new Set();
       implementers.add(this);
@@ -4541,8 +4557,19 @@ export class Class extends TypedElement {
           implementers.add(extender);
         }
       }
-      nextIface = <Interface | null>nextIface.base;
-    } while (nextIface);
+
+      let nextIfaces = nextIface.interfaces;
+      if (!nextIfaces) continue;
+
+      let stackIndex = ifaceStack.length;
+
+      // Calls the internal ensureCapacity() when run in the bootstrapped compiler:
+      ifaceStack.length = stackIndex + nextIfaces.size;
+  
+      for (let _values = Set_values(nextIfaces), i = 0, k = _values.length; i < k; ++i) {
+        ifaceStack[stackIndex++] = unchecked(_values[i]);
+      }
+    } while (ifaceStack.length);
   }
 
   /** Adds an interface. */
@@ -4561,7 +4588,7 @@ export class Class extends TypedElement {
     if (target.isInterface) {
       if (this.isInterface) {
         // targetInterface = thisInterface
-        return this == target || this.extends(target);
+        return this == target || this.implements(<Interface>target);
       } else {
         // targetInterface = thisClass
         return this.implements(<Interface>target);
@@ -4835,7 +4862,7 @@ export class Class extends TypedElement {
     return true;
   }
 
-  /** Tests if this class or interface extends the given class or interface. */
+  /** Tests if this class extends the given class. */
   extends(other: Class): bool {
     return other.hasExtender(this);
   }