Serialize inaccessible class declarations the same as class expressions in declaration emit (microsoft#49440)

weswigham · web-flow · commit ce639352bb8b · 2022-06-08T16:33:09.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -5221,7 +5221,7 @@ namespace ts {
                         // Always use 'typeof T' for type of class, enum, and module objects
                         else if (symbol.flags & SymbolFlags.Class
                             && !getBaseTypeVariableOfClass(symbol)
-                            && !(symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.ClassExpression && context.flags & NodeBuilderFlags.WriteClassExpressionAsTypeLiteral) ||
+                            && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & NodeBuilderFlags.WriteClassExpressionAsTypeLiteral && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(symbol, context.enclosingDeclaration, isInstanceType, /*computeAliases*/ false).accessibility !== SymbolAccessibility.Accessible)) ||
                             symbol.flags & (SymbolFlags.Enum | SymbolFlags.ValueModule) ||
                             shouldWriteTypeOfFunctionSymbol()) {
                             return symbolToTypeNode(symbol, context, isInstanceType);
diff --git a/tests/baselines/reference/declarationEmitClassMixinLocalClassDeclaration.js b/tests/baselines/reference/declarationEmitClassMixinLocalClassDeclaration.js
@@ -0,0 +1,88 @@
+//// [declarationEmitClassMixinLocalClassDeclaration.ts]
+export type AnyFunction<Result = any> = (...input: any[]) => Result
+
+export type AnyConstructor<Instance extends object = object, Static extends object = object> =
+    (new (...input: any[]) => Instance) & Static
+
+
+type MixinHelperFunc = <A extends AnyConstructor, T>(required: [A], arg: T) => T extends AnyFunction<infer M> ? M : never
+
+
+export const Mixin: MixinHelperFunc = null as any
+
+
+export class Base {}
+
+
+export class XmlElement2 extends Mixin(
+    [Base],
+    (base: AnyConstructor<Base, typeof Base>) => {
+        class XmlElement2 extends base {
+            num: number = 0
+        }
+        return XmlElement2;
+    }) { }
+
+
+//// [declarationEmitClassMixinLocalClassDeclaration.js]
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.XmlElement2 = exports.Base = exports.Mixin = void 0;
+exports.Mixin = null;
+var Base = /** @class */ (function () {
+    function Base() {
+    }
+    return Base;
+}());
+exports.Base = Base;
+var XmlElement2 = /** @class */ (function (_super) {
+    __extends(XmlElement2, _super);
+    function XmlElement2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return XmlElement2;
+}((0, exports.Mixin)([Base], function (base) {
+    var XmlElement2 = /** @class */ (function (_super) {
+        __extends(XmlElement2, _super);
+        function XmlElement2() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.num = 0;
+            return _this;
+        }
+        return XmlElement2;
+    }(base));
+    return XmlElement2;
+})));
+exports.XmlElement2 = XmlElement2;
+
+
+//// [declarationEmitClassMixinLocalClassDeclaration.d.ts]
+export declare type AnyFunction<Result = any> = (...input: any[]) => Result;
+export declare type AnyConstructor<Instance extends object = object, Static extends object = object> = (new (...input: any[]) => Instance) & Static;
+declare type MixinHelperFunc = <A extends AnyConstructor, T>(required: [A], arg: T) => T extends AnyFunction<infer M> ? M : never;
+export declare const Mixin: MixinHelperFunc;
+export declare class Base {
+}
+declare const XmlElement2_base: {
+    new (): {
+        num: number;
+    };
+};
+export declare class XmlElement2 extends XmlElement2_base {
+}
+export {};
diff --git a/tests/baselines/reference/declarationEmitClassMixinLocalClassDeclaration.symbols b/tests/baselines/reference/declarationEmitClassMixinLocalClassDeclaration.symbols
@@ -0,0 +1,67 @@
+=== tests/cases/compiler/declarationEmitClassMixinLocalClassDeclaration.ts ===
+export type AnyFunction<Result = any> = (...input: any[]) => Result
+>AnyFunction : Symbol(AnyFunction, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 0, 0))
+>Result : Symbol(Result, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 0, 24))
+>input : Symbol(input, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 0, 41))
+>Result : Symbol(Result, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 0, 24))
+
+export type AnyConstructor<Instance extends object = object, Static extends object = object> =
+>AnyConstructor : Symbol(AnyConstructor, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 0, 67))
+>Instance : Symbol(Instance, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 2, 27))
+>Static : Symbol(Static, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 2, 60))
+
+    (new (...input: any[]) => Instance) & Static
+>input : Symbol(input, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 3, 10))
+>Instance : Symbol(Instance, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 2, 27))
+>Static : Symbol(Static, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 2, 60))
+
+
+type MixinHelperFunc = <A extends AnyConstructor, T>(required: [A], arg: T) => T extends AnyFunction<infer M> ? M : never
+>MixinHelperFunc : Symbol(MixinHelperFunc, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 3, 48))
+>A : Symbol(A, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 6, 24))
+>AnyConstructor : Symbol(AnyConstructor, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 0, 67))
+>T : Symbol(T, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 6, 49))
+>required : Symbol(required, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 6, 53))
+>A : Symbol(A, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 6, 24))
+>arg : Symbol(arg, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 6, 67))
+>T : Symbol(T, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 6, 49))
+>T : Symbol(T, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 6, 49))
+>AnyFunction : Symbol(AnyFunction, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 0, 0))
+>M : Symbol(M, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 6, 106))
+>M : Symbol(M, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 6, 106))
+
+
+export const Mixin: MixinHelperFunc = null as any
+>Mixin : Symbol(Mixin, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 9, 12))
+>MixinHelperFunc : Symbol(MixinHelperFunc, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 3, 48))
+
+
+export class Base {}
+>Base : Symbol(Base, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 9, 49))
+
+
+export class XmlElement2 extends Mixin(
+>XmlElement2 : Symbol(XmlElement2, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 12, 20))
+>Mixin : Symbol(Mixin, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 9, 12))
+
+    [Base],
+>Base : Symbol(Base, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 9, 49))
+
+    (base: AnyConstructor<Base, typeof Base>) => {
+>base : Symbol(base, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 17, 5))
+>AnyConstructor : Symbol(AnyConstructor, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 0, 67))
+>Base : Symbol(Base, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 9, 49))
+>Base : Symbol(Base, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 9, 49))
+
+        class XmlElement2 extends base {
+>XmlElement2 : Symbol(XmlElement2, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 17, 50))
+>base : Symbol(base, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 17, 5))
+
+            num: number = 0
+>num : Symbol(XmlElement2.num, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 18, 40))
+        }
+        return XmlElement2;
+>XmlElement2 : Symbol(XmlElement2, Decl(declarationEmitClassMixinLocalClassDeclaration.ts, 17, 50))
+
+    }) { }
+
diff --git a/tests/baselines/reference/declarationEmitClassMixinLocalClassDeclaration.types b/tests/baselines/reference/declarationEmitClassMixinLocalClassDeclaration.types
@@ -0,0 +1,55 @@
+=== tests/cases/compiler/declarationEmitClassMixinLocalClassDeclaration.ts ===
+export type AnyFunction<Result = any> = (...input: any[]) => Result
+>AnyFunction : AnyFunction<Result>
+>input : any[]
+
+export type AnyConstructor<Instance extends object = object, Static extends object = object> =
+>AnyConstructor : AnyConstructor<Instance, Static>
+
+    (new (...input: any[]) => Instance) & Static
+>input : any[]
+
+
+type MixinHelperFunc = <A extends AnyConstructor, T>(required: [A], arg: T) => T extends AnyFunction<infer M> ? M : never
+>MixinHelperFunc : <A extends AnyConstructor<object, object>, T>(required: [A], arg: T) => T extends AnyFunction<infer M> ? M : never
+>required : [A]
+>arg : T
+
+
+export const Mixin: MixinHelperFunc = null as any
+>Mixin : MixinHelperFunc
+>null as any : any
+>null : null
+
+
+export class Base {}
+>Base : Base
+
+
+export class XmlElement2 extends Mixin(
+>XmlElement2 : XmlElement2
+>Mixin(    [Base],    (base: AnyConstructor<Base, typeof Base>) => {        class XmlElement2 extends base {            num: number = 0        }        return XmlElement2;    }) : XmlElement2
+>Mixin : MixinHelperFunc
+
+    [Base],
+>[Base] : [typeof Base]
+>Base : typeof Base
+
+    (base: AnyConstructor<Base, typeof Base>) => {
+>(base: AnyConstructor<Base, typeof Base>) => {        class XmlElement2 extends base {            num: number = 0        }        return XmlElement2;    } : (base: AnyConstructor<Base, typeof Base>) => typeof XmlElement2
+>base : AnyConstructor<Base, typeof Base>
+>Base : typeof Base
+
+        class XmlElement2 extends base {
+>XmlElement2 : XmlElement2
+>base : Base
+
+            num: number = 0
+>num : number
+>0 : 0
+        }
+        return XmlElement2;
+>XmlElement2 : typeof XmlElement2
+
+    }) { }
+
diff --git a/tests/baselines/reference/jsDeclarationsParameterTagReusesInputNodeInEmit1.errors.txt b/tests/baselines/reference/jsDeclarationsParameterTagReusesInputNodeInEmit1.errors.txt
diff --git a/tests/baselines/reference/jsDeclarationsParameterTagReusesInputNodeInEmit1.js b/tests/baselines/reference/jsDeclarationsParameterTagReusesInputNodeInEmit1.js
@@ -67,3 +67,35 @@ declare namespace BaseFactory {
 }
 declare class Base {
 }
+//// [file.d.ts]
+type couldntThinkOfAny = {
+    (): {};
+    Base: {
+        new (): {};
+    };
+};
+/** @typedef {import('./base')} BaseFactory */
+/**
+ * @callback BaseFactoryFactory
+ * @param {import('./base')} factory
+ */
+/** @enum {import('./base')} */
+declare const couldntThinkOfAny: {};
+/**
+ *
+ * @param {InstanceType<BaseFactory["Base"]>} base
+ * @returns {InstanceType<BaseFactory["Base"]>}
+ */
+declare function test(base: InstanceType<BaseFactory["Base"]>): InstanceType<BaseFactory["Base"]>;
+type BaseFactory = {
+    (): {};
+    Base: {
+        new (): {};
+    };
+};
+type BaseFactoryFactory = (factory: {
+    (): {};
+    Base: {
+        new (): {};
+    };
+}) => any;
diff --git a/tests/cases/compiler/declarationEmitClassMixinLocalClassDeclaration.ts b/tests/cases/compiler/declarationEmitClassMixinLocalClassDeclaration.ts
@@ -0,0 +1,24 @@
+// @declaration: true
+export type AnyFunction<Result = any> = (...input: any[]) => Result
+
+export type AnyConstructor<Instance extends object = object, Static extends object = object> =
+    (new (...input: any[]) => Instance) & Static
+
+
+type MixinHelperFunc = <A extends AnyConstructor, T>(required: [A], arg: T) => T extends AnyFunction<infer M> ? M : never
+
+
+export const Mixin: MixinHelperFunc = null as any
+
+
+export class Base {}
+
+
+export class XmlElement2 extends Mixin(
+    [Base],
+    (base: AnyConstructor<Base, typeof Base>) => {
+        class XmlElement2 extends base {
+            num: number = 0
+        }
+        return XmlElement2;
+    }) { }
diff --git a/tests/cases/fourslash/getDeclarationDiagnostics.ts b/tests/cases/fourslash/getDeclarationDiagnostics.ts
@@ -6,7 +6,7 @@
 // @Filename: inputFile1.ts
 //// module m {
 ////    export function foo() {
-////        class C implements I { }
+////        class C implements I { private a; }
 ////        interface I { }
 ////        return C;
 ////    }
diff --git a/tests/cases/fourslash/getSemanticDiagnosticForDeclaration.ts b/tests/cases/fourslash/getSemanticDiagnosticForDeclaration.ts
@@ -4,7 +4,7 @@
 // @declaration: true
 //// export function /*1*/foo/*2*/() {
 ////     interface privateInterface {}
-////     class Bar implements privateInterface { }
+////     class Bar implements privateInterface { private a; }
 ////     return Bar;
 //// }
 
diff --git a/tests/cases/fourslash/shims-pp/getSemanticDiagnostics.ts b/tests/cases/fourslash/shims-pp/getSemanticDiagnostics.ts
@@ -4,7 +4,7 @@
 // @declaration: true
 //// export function /*1*/foo/*2*/() {
 ////     interface privateInterface {}
-////     class Bar implements privateInterface { }
+////     class Bar implements privateInterface { private a; }
 ////     return Bar;
 //// }
 
diff --git a/tests/cases/fourslash/shims/getSemanticDiagnostics.ts b/tests/cases/fourslash/shims/getSemanticDiagnostics.ts
@@ -4,7 +4,7 @@
 // @declaration: true
 //// export function /*1*/foo/*2*/() {
 ////     interface privateInterface {}
-////     class Bar implements privateInterface { }
+////     class Bar implements privateInterface { private a; }
 ////     return Bar;
 //// }
 
