Merge pull request microsoft#15537 from Microsoft/emit-declaration-of-class-extending-intersection

Emit declaration of class extending intersection

Author: sandersn

src/compiler/checker.ts

@@ -22750,16 +22750,6 @@ namespace ts {
             getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
         }
 
-        function writeBaseConstructorTypeOfClass(node: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) {
-            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);
-        }
-
         function hasGlobalName(name: string): boolean {
             return globals.has(name);
         }
@@ -22853,7 +22843,6 @@ namespace ts {
                 writeTypeOfDeclaration,
                 writeReturnTypeOfSignatureDeclaration,
                 writeTypeOfExpression,
-                writeBaseConstructorTypeOfClass,
                 isSymbolAccessible,
                 isEntityNameVisible,
                 getConstantValue: node => {

src/compiler/declarationEmitter.ts

@@ -594,12 +594,11 @@ namespace ts {
             emitLines(node.statements);
         }
 
-        // Return a temp variable name to be used in `export default` statements.
+        // Return a temp variable name to be used in `export default`/`export class ... extends` statements.
         // The temp name will be of the form _default_counter.
         // Note that export default is only allowed at most once in a module, so we
         // do not need to keep track of created temp names.
-        function getExportDefaultTempVariableName(): string {
-            const baseName = "_default";
+        function getExportTempVariableName(baseName: string): string {
             if (!currentIdentifiers.has(baseName)) {
                 return baseName;
             }
@@ -613,24 +612,31 @@ namespace ts {
             }
         }
 
+        function emitTempVariableDeclaration(expr: Expression, baseName: string, diagnostic: SymbolAccessibilityDiagnostic): string {
+            const tempVarName = getExportTempVariableName(baseName);
+            if (!noDeclare) {
+                write("declare ");
+            }
+            write("const ");
+            write(tempVarName);
+            write(": ");
+            writer.getSymbolAccessibilityDiagnostic = () => diagnostic;
+            resolver.writeTypeOfExpression(expr, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction | TypeFormatFlags.UseTypeAliasValue, writer);
+            write(";");
+            writeLine();
+            return tempVarName;
+        }
+
         function emitExportAssignment(node: ExportAssignment) {
             if (node.expression.kind === SyntaxKind.Identifier) {
                 write(node.isExportEquals ? "export = " : "export default ");
                 writeTextOfNode(currentText, node.expression);
             }
             else {
-                // Expression
-                const tempVarName = getExportDefaultTempVariableName();
-                if (!noDeclare) {
-                    write("declare ");
-                }
-                write("var ");
-                write(tempVarName);
-                write(": ");
-                writer.getSymbolAccessibilityDiagnostic = getDefaultExportAccessibilityDiagnostic;
-                resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction | TypeFormatFlags.UseTypeAliasValue, writer);
-                write(";");
-                writeLine();
+                const tempVarName = emitTempVariableDeclaration(node.expression, "_default", {
+                    diagnosticMessage: Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0,
+                    errorNode: node
+                });
                 write(node.isExportEquals ? "export = " : "export default ");
                 write(tempVarName);
             }
@@ -644,13 +650,6 @@ namespace ts {
                 // write each of these declarations asynchronously
                 writeAsynchronousModuleElements(nodes);
             }
-
-            function getDefaultExportAccessibilityDiagnostic(): SymbolAccessibilityDiagnostic {
-                return {
-                    diagnosticMessage: Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0,
-                    errorNode: node
-                };
-            }
         }
 
         function isModuleElementVisible(node: Declaration) {
@@ -1097,7 +1096,7 @@ namespace ts {
             }
         }
 
-        function emitHeritageClause(className: Identifier, typeReferences: ExpressionWithTypeArguments[], isImplementsList: boolean) {
+        function emitHeritageClause(typeReferences: ExpressionWithTypeArguments[], isImplementsList: boolean) {
             if (typeReferences) {
                 write(isImplementsList ? " implements " : " extends ");
                 emitCommaList(typeReferences, emitTypeOfTypeReference);
@@ -1110,12 +1109,6 @@ namespace ts {
                 else if (!isImplementsList && node.expression.kind === SyntaxKind.NullKeyword) {
                     write("null");
                 }
-                else {
-                    writer.getSymbolAccessibilityDiagnostic = getHeritageClauseVisibilityError;
-                    errorNameNode = className;
-                    resolver.writeBaseConstructorTypeOfClass(<ClassLikeDeclaration>enclosingDeclaration, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction | TypeFormatFlags.UseTypeAliasValue, writer);
-                    errorNameNode = undefined;
-                }
 
                 function getHeritageClauseVisibilityError(): SymbolAccessibilityDiagnostic {
                     let diagnosticMessage: DiagnosticMessage;
@@ -1151,23 +1144,43 @@ namespace ts {
                 }
             }
 
+            const prevEnclosingDeclaration = enclosingDeclaration;
+            enclosingDeclaration = node;
+            const baseTypeNode = getClassExtendsHeritageClauseElement(node);
+            let tempVarName: string;
+            if (baseTypeNode && !isEntityNameExpression(baseTypeNode.expression)) {
+                tempVarName = baseTypeNode.expression.kind === SyntaxKind.NullKeyword ?
+                    "null" :
+                    emitTempVariableDeclaration(baseTypeNode.expression, `${node.name.text}_base`, {
+                        diagnosticMessage: Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1,
+                        errorNode: baseTypeNode,
+                        typeName: node.name
+                    });
+            }
+
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
             if (hasModifier(node, ModifierFlags.Abstract)) {
                 write("abstract ");
             }
-
             write("class ");
             writeTextOfNode(currentText, node.name);
-            const prevEnclosingDeclaration = enclosingDeclaration;
-            enclosingDeclaration = node;
             emitTypeParameters(node.typeParameters);
-            const baseTypeNode = getClassExtendsHeritageClauseElement(node);
             if (baseTypeNode) {
-                node.name;
-                emitHeritageClause(node.name, [baseTypeNode], /*isImplementsList*/ false);
+                if (!isEntityNameExpression(baseTypeNode.expression)) {
+                    write(" extends ");
+                    write(tempVarName);
+                    if (baseTypeNode.typeArguments) {
+                        write("<");
+                        emitCommaList(baseTypeNode.typeArguments, emitType);
+                        write(">");
+                    }
+                }
+                else  {
+                    emitHeritageClause([baseTypeNode], /*isImplementsList*/ false);
+                }
             }
-            emitHeritageClause(node.name, getClassImplementsHeritageClauseElements(node), /*isImplementsList*/ true);
+            emitHeritageClause(getClassImplementsHeritageClauseElements(node), /*isImplementsList*/ true);
             write(" {");
             writeLine();
             increaseIndent();
@@ -1189,7 +1202,7 @@ namespace ts {
             emitTypeParameters(node.typeParameters);
             const interfaceExtendsTypes = filter(getInterfaceBaseTypeNodes(node), base => isEntityNameExpression(base.expression));
             if (interfaceExtendsTypes && interfaceExtendsTypes.length) {
-                emitHeritageClause(node.name, interfaceExtendsTypes, /*isImplementsList*/ false);
+                emitHeritageClause(interfaceExtendsTypes, /*isImplementsList*/ false);
             }
             write(" {");
             writeLine();

src/compiler/types.ts

@@ -2734,7 +2734,6 @@ namespace ts {
         writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
-        writeBaseConstructorTypeOfClass(node: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, shouldComputeAliasToMarkVisible: boolean): SymbolAccessibilityResult;
         isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant

tests/baselines/reference/declarationEmitDefaultExport5.js

@@ -7,5 +7,5 @@ export default 1 + 2;
 
 
 //// [declarationEmitDefaultExport5.d.ts]
-declare var _default: number;
+declare const _default: number;
 export default _default;

tests/baselines/reference/declarationEmitDefaultExport6.js

@@ -12,5 +12,5 @@ export default new A();
 //// [declarationEmitDefaultExport6.d.ts]
 export declare class A {
 }
-declare var _default: A;
+declare const _default: A;
 export default _default;

tests/baselines/reference/declarationEmitDefaultExport8.js

@@ -13,5 +13,5 @@ export default 1 + 2;
 //// [declarationEmitDefaultExport8.d.ts]
 declare var _default: number;
 export { _default as d };
-declare var _default_1: number;
+declare const _default_1: number;
 export default _default_1;

tests/baselines/reference/declarationEmitDefaultExportWithTempVarName.js

@@ -15,5 +15,5 @@ System.register([], function (exports_1, context_1) {
 
 
 //// [pi.d.ts]
-declare var _default: 3.14159;
+declare const _default: 3.14159;
 export default _default;

tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.js

@@ -16,6 +16,6 @@ System.register("pi", [], function (exports_1, context_1) {
 
 //// [app.d.ts]
 declare module "pi" {
-    var _default: 3.14159;
+    const _default: 3.14159;
     export default _default;
 }

tests/baselines/reference/declarationEmitExpressionInExtends2.js

@@ -45,5 +45,6 @@ declare class C<T, U> {
     y: U;
 }
 declare function getClass<T>(c: T): typeof C;
-declare class MyClass extends C<string, number> {
+declare const MyClass_base: typeof C;
+declare class MyClass extends MyClass_base<string, number> {
 }

tests/baselines/reference/declarationEmitExpressionInExtends3.errors.txt

@@ -1,5 +1,5 @@
 tests/cases/compiler/declarationEmitExpressionInExtends3.ts(28,30): error TS4020: 'extends' clause of exported class 'MyClass' has or is using private name 'LocalClass'.
-tests/cases/compiler/declarationEmitExpressionInExtends3.ts(36,31): error TS4020: 'extends' clause of exported class 'MyClass3' has or is using private name 'LocalInterface'.
+tests/cases/compiler/declarationEmitExpressionInExtends3.ts(36,75): error TS4020: 'extends' clause of exported class 'MyClass3' has or is using private name 'LocalInterface'.
 
 
 ==== tests/cases/compiler/declarationEmitExpressionInExtends3.ts (2 errors) ====
@@ -41,7 +41,7 @@ tests/cases/compiler/declarationEmitExpressionInExtends3.ts(36,31): error TS4020
 
 
     export class MyClass3 extends getExportedClass<LocalInterface>(undefined)<LocalInterface> { // Error LocalInterface is inaccisble
-                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                                                                              ~~~~~~~~~~~~~~
 !!! error TS4020: 'extends' clause of exported class 'MyClass3' has or is using private name 'LocalInterface'.
     }
 

tests/baselines/reference/declarationEmitExpressionInExtends4.errors.txt

@@ -1,30 +1,27 @@
 tests/cases/compiler/declarationEmitExpressionInExtends4.ts(1,10): error TS4060: Return type of exported function has or is using private name 'D'.
-tests/cases/compiler/declarationEmitExpressionInExtends4.ts(5,7): error TS4093: 'extends' clause of exported class 'C' refers to a type whose name cannot be referenced.
 tests/cases/compiler/declarationEmitExpressionInExtends4.ts(5,17): error TS2315: Type 'D' is not generic.
-tests/cases/compiler/declarationEmitExpressionInExtends4.ts(9,7): error TS4093: 'extends' clause of exported class 'C2' refers to a type whose name cannot be referenced.
+tests/cases/compiler/declarationEmitExpressionInExtends4.ts(5,17): error TS4020: 'extends' clause of exported class 'C' has or is using private name 'D'.
 tests/cases/compiler/declarationEmitExpressionInExtends4.ts(9,18): error TS2304: Cannot find name 'SomeUndefinedFunction'.
 tests/cases/compiler/declarationEmitExpressionInExtends4.ts(14,18): error TS2304: Cannot find name 'SomeUndefinedFunction'.
 tests/cases/compiler/declarationEmitExpressionInExtends4.ts(14,18): error TS4020: 'extends' clause of exported class 'C3' has or is using private name 'SomeUndefinedFunction'.
 
 
-==== tests/cases/compiler/declarationEmitExpressionInExtends4.ts (7 errors) ====
+==== tests/cases/compiler/declarationEmitExpressionInExtends4.ts (6 errors) ====
     function getSomething() {
              ~~~~~~~~~~~~
 !!! error TS4060: Return type of exported function has or is using private name 'D'.
         return class D { }
     }
 
     class C extends getSomething()<number, string> {
-          ~
-!!! error TS4093: 'extends' clause of exported class 'C' refers to a type whose name cannot be referenced.
                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2315: Type 'D' is not generic.
+                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4020: 'extends' clause of exported class 'C' has or is using private name 'D'.
 
     }
 
     class C2 extends SomeUndefinedFunction()<number, string> {
-          ~~
-!!! error TS4093: 'extends' clause of exported class 'C2' refers to a type whose name cannot be referenced.
                      ~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2304: Cannot find name 'SomeUndefinedFunction'.
 

tests/baselines/reference/declarationEmitInferedDefaultExportType.js

@@ -18,7 +18,7 @@ exports["default"] = {
 
 
 //// [declarationEmitInferedDefaultExportType.d.ts]
-declare var _default: {
+declare const _default: {
     foo: any[];
     bar: any;
     baz: any;

tests/baselines/reference/declarationEmitInferedDefaultExportType2.js

@@ -16,7 +16,7 @@ module.exports = {
 
 
 //// [declarationEmitInferedDefaultExportType2.d.ts]
-declare var _default: {
+declare const _default: {
     foo: any[];
     bar: any;
     baz: any;

tests/baselines/reference/es5ExportDefaultExpression.js

@@ -9,5 +9,5 @@ exports.default = (1 + 2);
 
 
 //// [es5ExportDefaultExpression.d.ts]
-declare var _default: number;
+declare const _default: number;
 export default _default;

tests/baselines/reference/es6ExportDefaultExpression.js

@@ -7,5 +7,5 @@ export default (1 + 2);
 
 
 //// [es6ExportDefaultExpression.d.ts]
-declare var _default: number;
+declare const _default: number;
 export default _default;

tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js

@@ -48,6 +48,6 @@ var x1 = es6ImportDefaultBindingFollowedWithNamedImport_0_5.m;
 export declare var a: number;
 export declare var x: number;
 export declare var m: number;
-declare var _default: {};
+declare const _default: {};
 export default _default;
 //// [es6ImportDefaultBindingFollowedWithNamedImport_1.d.ts]

tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.js

@@ -47,7 +47,7 @@ define(["require", "exports", "server", "server", "server", "server", "server"],
 export declare var a: number;
 export declare var x: number;
 export declare var m: number;
-declare var _default: {};
+declare const _default: {};
 export default _default;
 //// [client.d.ts]
 export declare var x1: number;

tests/baselines/reference/exportClassExtendingIntersection.errors.txt

@@ -111,4 +111,11 @@ export interface MyMixin {
     mixinProperty: string;
 }
 export declare function MyMixin<T extends Constructor<MyBaseClass<any>>>(base: T): T & Constructor<MyMixin>;
+//// [FinalClass.d.ts]
+import { MyBaseClass } from './BaseClass';
+import { MyMixin } from './MixinClass';
+declare const MyExtendedClass_base: typeof MyBaseClass & (new (...args: any[]) => MyMixin);
+export declare class MyExtendedClass extends MyExtendedClass_base<string> {
+    extendedClassProperty: number;
+}
 //// [Main.d.ts]