Error on emit declaration of extends class w/o symbol

sandersn · sandersn · commit cd272e824496 · 2017-02-14T12:42:32.000-08:00
Error when emitting an extends clause for a type that has no symbol.
This error only occurs on exported classes.
This prevents the emitter from producing types that extend from
intersections, which are not parseable right now.
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -20844,6 +20844,9 @@ namespace ts {
             const classType = <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(node));
             resolveBaseTypesOfClass(classType);
             const baseType = classType.resolvedBaseTypes.length ? classType.resolvedBaseTypes[0] : unknownType;
+            if (!baseType.symbol) {
+                writer.reportIllegalExtends();
+            }
             getSymbolDisplayBuilder().buildTypeDisplay(baseType, writer, enclosingDeclaration, flags);
         }
 
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
@@ -190,6 +190,7 @@ namespace ts {
             const writer = <EmitTextWriterWithSymbolWriter>createTextWriter(newLine);
             writer.trackSymbol = trackSymbol;
             writer.reportInaccessibleThisError = reportInaccessibleThisError;
+            writer.reportIllegalExtends = reportIllegalExtends;
             writer.writeKeyword = writer.write;
             writer.writeOperator = writer.write;
             writer.writePunctuation = writer.write;
@@ -313,6 +314,14 @@ namespace ts {
             recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning));
         }
 
+        function reportIllegalExtends() {
+            if (errorNameNode) {
+                reportedDeclarationError = true;
+                emitterDiagnostics.add(createDiagnosticForNode(errorNameNode, Diagnostics.Extends_clause_of_exported_class_0_refers_to_a_type_with_no_declaration,
+                    declarationNameToString(errorNameNode)));
+            }
+        }
+
         function reportInaccessibleThisError() {
             if (errorNameNode) {
                 reportedDeclarationError = true;
@@ -1071,7 +1080,7 @@ namespace ts {
             }
         }
 
-        function emitHeritageClause(typeReferences: ExpressionWithTypeArguments[], isImplementsList: boolean) {
+        function emitHeritageClause(className: Identifier, typeReferences: ExpressionWithTypeArguments[], isImplementsList: boolean) {
             if (typeReferences) {
                 write(isImplementsList ? " implements " : " extends ");
                 emitCommaList(typeReferences, emitTypeOfTypeReference);
@@ -1086,7 +1095,9 @@ namespace ts {
                 }
                 else {
                     writer.getSymbolAccessibilityDiagnostic = getHeritageClauseVisibilityError;
+                    errorNameNode = className;
                     resolver.writeBaseConstructorTypeOfClass(<ClassLikeDeclaration>enclosingDeclaration, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction | TypeFormatFlags.UseTypeAliasValue, writer);
+                    errorNameNode = undefined;
                 }
 
                 function getHeritageClauseVisibilityError(): SymbolAccessibilityDiagnostic {
@@ -1136,9 +1147,10 @@ namespace ts {
             emitTypeParameters(node.typeParameters);
             const baseTypeNode = getClassExtendsHeritageClauseElement(node);
             if (baseTypeNode) {
-                emitHeritageClause([baseTypeNode], /*isImplementsList*/ false);
+                node.name
+                emitHeritageClause(node.name, [baseTypeNode], /*isImplementsList*/ false);
             }
-            emitHeritageClause(getClassImplementsHeritageClauseElements(node), /*isImplementsList*/ true);
+            emitHeritageClause(node.name, getClassImplementsHeritageClauseElements(node), /*isImplementsList*/ true);
             write(" {");
             writeLine();
             increaseIndent();
@@ -1160,7 +1172,7 @@ namespace ts {
             emitTypeParameters(node.typeParameters);
             const interfaceExtendsTypes = filter(getInterfaceBaseTypeNodes(node), base => isEntityNameExpression(base.expression));
             if (interfaceExtendsTypes && interfaceExtendsTypes.length) {
-                emitHeritageClause(interfaceExtendsTypes, /*isImplementsList*/ false);
+                emitHeritageClause(node.name, interfaceExtendsTypes, /*isImplementsList*/ false);
             }
             write(" {");
             writeLine();
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -2352,6 +2352,10 @@
         "category": "Error",
         "code": 4092
     },
+    "Extends clause of exported class '{0}' refers to a type with no declaration.": {
+        "category": "Error",
+        "code": 4093
+    },
 
     "The current host does not support the '{0}' option.": {
         "category": "Error",
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2459,6 +2459,7 @@
         // with import statements it previously saw (but chose not to emit).
         trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
         reportInaccessibleThisError(): void;
+        reportIllegalExtends(): void;
     }
 
     export const enum TypeFormatFlags {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -53,7 +53,8 @@ namespace ts {
                 decreaseIndent: noop,
                 clear: () => str = "",
                 trackSymbol: noop,
-                reportInaccessibleThisError: noop
+                reportInaccessibleThisError: noop,
+                reportIllegalExtends: noop
             };
         }
 
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
@@ -1166,7 +1166,8 @@ namespace ts {
             decreaseIndent: () => { indent--; },
             clear: resetWriter,
             trackSymbol: noop,
-            reportInaccessibleThisError: noop
+            reportInaccessibleThisError: noop,
+            reportIllegalExtends: noop
         };
 
         function writeIndent() {
@@ -1386,4 +1387,4 @@ namespace ts {
         // First token is the open curly, this is where we want to put the 'super' call.
         return constructor.body.getFirstToken(sourceFile).getEnd();
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -20844,6 +20844,9 @@ namespace ts {`
`20844`	`20844`	`const classType = <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(node));`
`20845`	`20845`	`resolveBaseTypesOfClass(classType);`
`20846`	`20846`	`const baseType = classType.resolvedBaseTypes.length ? classType.resolvedBaseTypes[0] : unknownType;`
	`20847`	`+ if (!baseType.symbol) {`
	`20848`	`+ writer.reportIllegalExtends();`
	`20849`	`+ }`
`20847`	`20850`	`getSymbolDisplayBuilder().buildTypeDisplay(baseType, writer, enclosingDeclaration, flags);`
`20848`	`20851`	`}`
`20849`	`20852`
Original file line number	Diff line number	Diff line change
`@@ -2459,6 +2459,7 @@`
`2459`	`2459`	`// with import statements it previously saw (but chose not to emit).`
`2460`	`2460`	`trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;`
`2461`	`2461`	`reportInaccessibleThisError(): void;`
	`2462`	`+ reportIllegalExtends(): void;`
`2462`	`2463`	`}`
`2463`	`2464`
`2464`	`2465`	`export const enum TypeFormatFlags {`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,8 @@ namespace ts {`
`53`	`53`	`decreaseIndent: noop,`
`54`	`54`	`clear: () => str = "",`
`55`	`55`	`trackSymbol: noop,`
`56`		`- reportInaccessibleThisError: noop`
	`56`	`+ reportInaccessibleThisError: noop,`
	`57`	`+ reportIllegalExtends: noop`
`57`	`58`	`};`
`58`	`59`	`}`
`59`	`60`