nested type names, addresses #423 and #127

dcodeIO · dcodeIO · commit 31d5450033b3 · 2019-02-19T23:43:21.000+01:00
diff --git a/src/ast.ts b/src/ast.ts
@@ -31,6 +31,7 @@ export enum NodeKind {
 
   // types
   TYPE,
+  TYPENAME,
   TYPEPARAMETER,
   PARAMETER,
   SIGNATURE,
@@ -155,8 +156,26 @@ export abstract class Node {
 
   // types
 
-  static createType(
+  static createTypeName(
     name: IdentifierExpression,
+    range: Range
+  ): TypeName {
+    var typeName = new TypeName();
+    typeName.range = range;
+    typeName.identifier = name; name.parent = typeName;
+    typeName.next = null;
+    return typeName;
+  }
+
+  static createSimpleTypeName(
+    name: string,
+    range: Range
+  ): TypeName {
+    return Node.createTypeName(Node.createIdentifierExpression(name, range), range);
+  }
+
+  static createType(
+    name: TypeName,
     typeArguments: CommonTypeNode[] | null,
     isNullable: bool,
     range: Range
@@ -173,7 +192,7 @@ export abstract class Node {
     range: Range
   ): TypeNode {
     return Node.createType(
-      Node.createIdentifierExpression("", range),
+      Node.createSimpleTypeName("", range),
       null,
       false,
       range
@@ -1066,12 +1085,22 @@ export abstract class CommonTypeNode extends Node {
   isNullable: bool;
 }
 
+/** Represents a type name. */
+export class TypeName extends Node {
+  kind = NodeKind.TYPENAME;
+
+  /** Identifier of this part. */
+  identifier: IdentifierExpression;
+  /** Next part of the type name or `null` if this is the last part. */
+  next: TypeName | null;
+}
+
 /** Represents a type annotation. */
 export class TypeNode extends CommonTypeNode {
   kind = NodeKind.TYPE;
 
-  /** Identifier reference. */
-  name: IdentifierExpression;
+  /** Type name. */
+  name: TypeName;
   /** Type argument references. */
   typeArguments: CommonTypeNode[] | null;
 }
diff --git a/src/compiler.ts b/src/compiler.ts
@@ -5068,7 +5068,9 @@ export class Compiler extends DiagnosticEmitter {
           let argumentExprs = new Array<ExpressionRef>(numArguments);
           for (let i = 0; i < numParameters; ++i) {
             let typeNode = parameterNodes[i].type;
-            let name = typeNode.kind == NodeKind.TYPE ? (<TypeNode>typeNode).name.text : null;
+            let templateName = typeNode.kind == NodeKind.TYPE && !(<TypeNode>typeNode).name.next
+              ? (<TypeNode>typeNode).name.identifier.text
+              : null;
             let argumentExpression = i < numArguments
               ? argumentNodes[i]
               : parameterNodes[i].initializer;
@@ -5079,8 +5081,8 @@ export class Compiler extends DiagnosticEmitter {
               );
               return module.createUnreachable();
             }
-            if (name !== null && inferredTypes.has(name)) {
-              let inferredType = inferredTypes.get(name);
+            if (templateName !== null && inferredTypes.has(templateName)) {
+              let inferredType = inferredTypes.get(templateName);
               if (inferredType) {
                 argumentExprs[i] = this.compileExpressionRetainType(argumentExpression, inferredType, WrapMode.NONE);
                 let commonType: Type | null;
@@ -5099,7 +5101,7 @@ export class Compiler extends DiagnosticEmitter {
                 inferredType = this.currentType;
                 // ++numInferred;
               }
-              inferredTypes.set(name, inferredType);
+              inferredTypes.set(templateName, inferredType);
             } else {
               let concreteType = this.resolver.resolveType(
                 parameterNodes[i].type,
diff --git a/src/extra/ast.ts b/src/extra/ast.ts
@@ -13,6 +13,7 @@ import {
 
   CommonTypeNode,
   TypeNode,
+  TypeName,
   TypeParameterNode,
   SignatureNode,
 
@@ -358,8 +359,7 @@ export class ASTBuilder {
       return;
     }
     var typeNode = <TypeNode>node;
-    assert(typeNode.name.text.length);
-    this.visitIdentifierExpression(typeNode.name);
+    this.visitTypeName((<TypeNode>node).name);
     var typeArguments = typeNode.typeArguments;
     if (typeArguments) {
       let numTypeArguments = typeArguments.length;
@@ -377,6 +377,17 @@ export class ASTBuilder {
     }
   }
 
+  visitTypeName(node: TypeName): void {
+    this.visitIdentifierExpression(node.identifier);
+    var sb = this.sb;
+    var current = node.next;
+    while (current) {
+      sb.push(".");
+      this.visitIdentifierExpression(current.identifier);
+      current = current.next;
+    }
+  }
+
   visitTypeParameter(node: TypeParameterNode): void {
     this.visitIdentifierExpression(node.name);
     var extendsType = node.extendsType;
@@ -1540,5 +1551,9 @@ export class ASTBuilder {
 }
 
 function isTypeOmitted(type: CommonTypeNode): bool {
-  return type.kind == NodeKind.TYPE && !changetype<TypeNode>(type).name.text.length;
+  if (type.kind == NodeKind.TYPE) {
+    let name = (<TypeNode>type).name;
+    return !(name.next || name.identifier.text.length);
+  }
+  return false;
 }
diff --git a/src/parser.ts b/src/parser.ts
@@ -431,42 +431,41 @@ export class Parser extends DiagnosticEmitter {
     // 'void'
     } else if (token == Token.VOID) {
       type = Node.createType(
-        Node.createIdentifierExpression("void", tn.range()), [], false, tn.range(startPos, tn.pos)
+        Node.createSimpleTypeName("void", tn.range()), [], false, tn.range(startPos, tn.pos)
       );
 
     // 'this'
     } else if (token == Token.THIS) {
       type = Node.createType(
-        Node.createThisExpression(tn.range()), [], false, tn.range(startPos, tn.pos)
+        Node.createSimpleTypeName("this", tn.range()), [], false, tn.range(startPos, tn.pos)
       );
 
     // 'true'
     } else if (token == Token.TRUE || token == Token.FALSE) {
       type = Node.createType(
-        Node.createIdentifierExpression("bool", tn.range()), [], false, tn.range(startPos, tn.pos)
+        Node.createSimpleTypeName("bool", tn.range()), [], false, tn.range(startPos, tn.pos)
       );
 
     // StringLiteral
     } else if (token == Token.STRINGLITERAL) {
       tn.readString();
       type = Node.createType(
-        Node.createIdentifierExpression("string", tn.range()), [], false, tn.range(startPos, tn.pos)
+        Node.createSimpleTypeName("string", tn.range()), [], false, tn.range(startPos, tn.pos)
       );
 
     // Identifier
     } else if (token == Token.IDENTIFIER) {
-      let identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
+      let first = Node.createSimpleTypeName(tn.readIdentifier(), tn.range());
+      let current = first;
       let parameters = new Array<TypeNode>();
       let nullable = false;
 
       // Identifier ('.' Identifier)+
       while (tn.skip(Token.DOT)) {
         if (tn.skip(Token.IDENTIFIER)) {
-          // TODO: this works for now, but the representation isn't great
-          identifier = Node.createIdentifierExpression(
-            identifier.text + "." + tn.readIdentifier(),
-            tn.range(identifier.range.start, tn.pos)
-          );
+          let next = Node.createSimpleTypeName(tn.readIdentifier(), tn.range());
+          current.next = next;
+          current = next;
         } else {
           this.error(
             DiagnosticCode.Identifier_expected,
@@ -507,7 +506,7 @@ export class Parser extends DiagnosticEmitter {
           return null;
         }
       }
-      type = Node.createType(identifier, parameters, nullable, tn.range(startPos, tn.pos));
+      type = Node.createType(first, parameters, nullable, tn.range(startPos, tn.pos));
 
     } else {
       if (!suppressErrors) {
@@ -548,7 +547,7 @@ export class Parser extends DiagnosticEmitter {
         }
       }
       type = Node.createType(
-        Node.createIdentifierExpression("Array", bracketRange),
+        Node.createSimpleTypeName("Array", bracketRange),
         [ type ],
         nullable,
         tn.range(startPos, tn.pos)
diff --git a/src/program.ts b/src/program.ts
@@ -401,7 +401,7 @@ export class Program extends DiagnosticEmitter {
       null,
       this.nativeDummySignature || (this.nativeDummySignature = Node.createSignature([],
         Node.createType( // ^ AST signature doesn't really matter, is overridden anyway
-          Node.createIdentifierExpression(CommonSymbols.void_, range),
+          Node.createSimpleTypeName(CommonSymbols.void_, range),
           null, false, range
         ),
         null, false, range)
@@ -661,14 +661,14 @@ export class Program extends DiagnosticEmitter {
     for (let i = 0, k = queuedExtends.length; i < k; ++i) {
       let thisPrototype = queuedExtends[i];
       let extendsNode = assert(thisPrototype.extendsNode); // must be present if in queuedExtends
-      let baseElement = resolver.resolveIdentifier(extendsNode.name, null, thisPrototype.parent); // reports
+      let baseElement = resolver.resolveTypeName(extendsNode.name, thisPrototype.parent); // reports
       if (!baseElement) continue;
       if (baseElement.kind == ElementKind.CLASS_PROTOTYPE) {
         let basePrototype = <ClassPrototype>baseElement;
         if (basePrototype.hasDecorator(DecoratorFlags.SEALED)) {
           this.error(
             DiagnosticCode.Class_0_is_sealed_and_cannot_be_extended,
-            extendsNode.range, extendsNode.name.text
+            extendsNode.range, (<ClassPrototype>baseElement).identifierNode.text
           );
         }
         if (
diff --git a/src/resolver.ts b/src/resolver.ts
@@ -37,6 +37,7 @@ import {
   CommonTypeNode,
   NodeKind,
   TypeNode,
+  TypeName,
   TypeParameterNode,
   Node,
   Range,
@@ -174,45 +175,39 @@ export class Resolver extends DiagnosticEmitter {
     // now dealing with TypeNode
     assert(node.kind == NodeKind.TYPE);
     var typeNode = <TypeNode>node;
-    var typeName = typeNode.name.text;
+    var typeName = typeNode.name;
     var typeArgumentNodes = typeNode.typeArguments;
 
-    // look up in contextual type arguments, i.e. `T`
-    if (contextualTypeArguments && contextualTypeArguments.has(typeName)) {
-      let type = contextualTypeArguments.get(typeName)!;
-      if (typeArgumentNodes !== null && typeArgumentNodes.length) {
-        if (reportMode == ReportMode.REPORT) {
-          this.error(
-            DiagnosticCode.Type_0_is_not_generic,
-            node.range, type.toString()
-          );
-        }
-      }
-      if (node.isNullable) {
-        if (!type.is(TypeFlags.REFERENCE)) {
+    // look up in contextual type arguments if a simple type name
+    if (!typeName.next) {
+      if (contextualTypeArguments && contextualTypeArguments.has(typeName.identifier.text)) {
+        let type = contextualTypeArguments.get(typeName.identifier.text)!;
+        if (typeArgumentNodes !== null && typeArgumentNodes.length) {
           if (reportMode == ReportMode.REPORT) {
             this.error(
-              DiagnosticCode.Basic_type_0_cannot_be_nullable,
+              DiagnosticCode.Type_0_is_not_generic,
               node.range, type.toString()
             );
           }
         }
-        return type.asNullable();
+        if (node.isNullable) {
+          if (!type.is(TypeFlags.REFERENCE)) {
+            if (reportMode == ReportMode.REPORT) {
+              this.error(
+                DiagnosticCode.Basic_type_0_cannot_be_nullable,
+                node.range, type.toString()
+              );
+            }
+          }
+          return type.asNullable();
+        }
+        return type;
       }
-      return type;
     }
 
     // look up in context
-    var element = context.lookup(typeName);
-    if (!element) {
-      if (reportMode == ReportMode.REPORT) {
-        this.error(
-          DiagnosticCode.Cannot_find_name_0,
-          typeNode.name.range, typeName
-        );
-      }
-      return null;
-    }
+    var element = this.resolveTypeName(typeName, context, reportMode);
+    if (!element) return null;
 
     // use shadow type if present (i.e. namespace sharing a type)
     if (element.shadowType) element = element.shadowType;
@@ -270,7 +265,7 @@ export class Resolver extends DiagnosticEmitter {
             if (reportMode == ReportMode.REPORT) {
               this.error(
                 DiagnosticCode.Basic_type_0_cannot_be_nullable,
-                typeNode.name.range, typeNode.name.text
+                typeNode.name.range, typeName.identifier.text
               );
             }
           } else {
@@ -281,7 +276,7 @@ export class Resolver extends DiagnosticEmitter {
       }
 
       // handle special native type
-      if (typeNode.name.text == CommonSymbols.native) {
+      if (!typeName.next && typeName.identifier.text == CommonSymbols.native) {
         if (!(typeArgumentNodes && typeArgumentNodes.length == 1)) {
           if (reportMode == ReportMode.REPORT) {
             this.error(
@@ -334,7 +329,7 @@ export class Resolver extends DiagnosticEmitter {
       } else if (typeArgumentNodes && typeArgumentNodes.length) {
         this.error(
           DiagnosticCode.Type_0_is_not_generic,
-          typeNode.range, typeNode.name.text
+          typeNode.range, typeName.identifier.text
         );
         // recoverable
       }
@@ -349,12 +344,42 @@ export class Resolver extends DiagnosticEmitter {
     if (reportMode == ReportMode.REPORT) {
       this.error(
         DiagnosticCode.Cannot_find_name_0,
-        typeNode.name.range, typeName
+        typeNode.name.range, typeName.identifier.text
       );
     }
     return null;
   }
 
+  /** Resolves the specified type name relative to the given context. */
+  resolveTypeName(typeName: TypeName, context: Element, reportMode = ReportMode.REPORT): Element | null {
+    var element = context.lookup(typeName.identifier.text);
+    if (!element) {
+      if (reportMode == ReportMode.REPORT) {
+        this.error(
+          DiagnosticCode.Cannot_find_name_0,
+          typeName.range, typeName.identifier.text
+        );
+      }
+      return null;
+    }
+    var prev = typeName;
+    var next = typeName.next;
+    while (next) {
+      if (!(element = element.lookupInSelf(next.identifier.text))) {
+        if (reportMode == ReportMode.REPORT) {
+          this.error(
+            DiagnosticCode.Property_0_does_not_exist_on_type_1,
+            next.range, next.identifier.text, prev.identifier.text
+          );
+        }
+        return null;
+      }
+      prev = next;
+      next = next.next;
+    }
+    return element;
+  }
+
   /** Resolves an array of type arguments to concrete types. */
   resolveTypeArguments(
     typeParameters: TypeParameterNode[],
diff --git a/tests/compiler/resolve-nested.optimized.wat b/tests/compiler/resolve-nested.optimized.wat
diff --git a/tests/compiler/resolve-nested.ts b/tests/compiler/resolve-nested.ts
diff --git a/tests/compiler/resolve-nested.untouched.wat b/tests/compiler/resolve-nested.untouched.wat
