Cache accessibe symbol chains and serialized type parameter name generation (#43973)

* Cache accessibe symbol chains, type parameter name generation

* Move signature declaration helper length approximation to start of function

* Add node result caching internal to `typeToTypeNodeHelper`

* Suggestion from PR

Author: weswigham

src/compiler/checker.ts

@@ -145,8 +145,10 @@ namespace ts {
                             symbolAccessibilityResult.errorSymbolName,
                             symbolAccessibilityResult.errorModuleName));
                     }
+                    return true;
                 }
             }
+            return false;
         }
 
         function trackExternalModuleSymbolOfImportTypeNode(symbol: Symbol) {
@@ -156,9 +158,10 @@ namespace ts {
         }
 
         function trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
-            if (symbol.flags & SymbolFlags.TypeParameter) return;
-            handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning, /*shouldComputeAliasesToMakeVisible*/ true));
+            if (symbol.flags & SymbolFlags.TypeParameter) return false;
+            const issuedDiagnostic = handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning, /*shouldComputeAliasesToMakeVisible*/ true));
             recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning));
+            return issuedDiagnostic;
         }
 
         function reportPrivateInBaseOfClassExpression(propertyName: string) {

src/compiler/transformers/declarations.ts

@@ -4831,6 +4831,7 @@ namespace ts {
         typeOnlyDeclaration?: TypeOnlyCompatibleAliasDeclaration | false; // First resolved alias declaration that makes the symbol only usable in type constructs
         isConstructorDeclaredProperty?: boolean;    // Property declared through 'this.x = ...' assignment in constructor
         tupleLabelDeclaration?: NamedTupleMember | ParameterDeclaration; // Declaration associated with the tuple's label
+        accessibleChainCache?: ESMap<string, Symbol[] | undefined>;
     }
 
     /* @internal */
@@ -4986,6 +4987,7 @@ namespace ts {
         isExhaustive?: boolean;             // Is node an exhaustive switch statement
         skipDirectInference?: true;         // Flag set by the API `getContextualType` call on a node when `Completions` is passed to force the checker to skip making inferences to a node's type
         declarationRequiresScopeChange?: boolean; // Set by `useOuterVariableScopeInParameter` in checker when downlevel emit would change the name resolution scope inside of a parameter.
+        serializedTypes?: ESMap<string, TypeNode & {truncating?: boolean, addedLength: number}>; // Collection of types serialized at this location
     }
 
     export const enum TypeFlags {
@@ -8118,7 +8120,7 @@ namespace ts {
         // Called when the symbol writer encounters a symbol to write.  Currently only used by the
         // declaration emitter to help determine if it should patch up the final declaration file
         // with import statements it previously saw (but chose not to emit).
-        trackSymbol?(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags): void;
+        trackSymbol?(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags): boolean;
         reportInaccessibleThisError?(): void;
         reportPrivateInBaseOfClassExpression?(propertyName: string): void;
         reportInaccessibleUniqueSymbolError?(): void;

src/compiler/types.ts

@@ -83,7 +83,7 @@ namespace ts {
             increaseIndent: noop,
             decreaseIndent: noop,
             clear: () => str = "",
-            trackSymbol: noop,
+            trackSymbol: () => false,
             reportInaccessibleThisError: noop,
             reportInaccessibleUniqueSymbolError: noop,
             reportPrivateInBaseOfClassExpression: noop,
@@ -4029,7 +4029,7 @@ namespace ts {
             reportInaccessibleThisError: noop,
             reportPrivateInBaseOfClassExpression: noop,
             reportInaccessibleUniqueSymbolError: noop,
-            trackSymbol: noop,
+            trackSymbol: () => false,
             writeKeyword: write,
             writeOperator: write,
             writeParameter: write,

src/compiler/utilities.ts

@@ -254,7 +254,11 @@ namespace compiler {
         if (compilerOptions.skipDefaultLibCheck === undefined) compilerOptions.skipDefaultLibCheck = true;
         if (compilerOptions.noErrorTruncation === undefined) compilerOptions.noErrorTruncation = true;
 
-        const preProgram = ts.length(rootFiles) < 100 ? ts.createProgram(rootFiles || [], { ...compilerOptions, configFile: compilerOptions.configFile, traceResolution: false }, host) : undefined;
+        // pre-emit/post-emit error comparison requires declaration emit twice, which can be slow. If it's unlikely to flag any error consistency issues
+        // and if the test is running `skipLibCheck` - an indicator that we want the tets to run quickly - skip the before/after error comparison, too
+        const skipErrorComparison = ts.length(rootFiles) >= 100 || (!!compilerOptions.skipLibCheck && !!compilerOptions.declaration);
+
+        const preProgram = !skipErrorComparison ? ts.createProgram(rootFiles || [], { ...compilerOptions, configFile: compilerOptions.configFile, traceResolution: false }, host) : undefined;
         const preErrors = preProgram && ts.getPreEmitDiagnostics(preProgram);
 
         const program = ts.createProgram(rootFiles || [], compilerOptions, host);

src/harness/compilerImpl.ts

@@ -18,7 +18,7 @@ namespace ts.codefix {
 
     export function getNoopSymbolTrackerWithResolver(context: TypeConstructionContext): SymbolTracker {
         return {
-            trackSymbol: noop,
+            trackSymbol: () => false,
             moduleResolverHost: getModuleSpecifierResolverHost(context.program, context.host),
         };
     }

src/services/codefixes/helpers.ts

@@ -2093,7 +2093,7 @@ namespace ts {
             increaseIndent: () => { indent++; },
             decreaseIndent: () => { indent--; },
             clear: resetWriter,
-            trackSymbol: noop,
+            trackSymbol: () => false,
             reportInaccessibleThisError: noop,
             reportInaccessibleUniqueSymbolError: noop,
             reportPrivateInBaseOfClassExpression: noop,
@@ -2619,6 +2619,7 @@ namespace ts {
         const res = checker.typeToTypeNode(type, enclosingScope, NodeBuilderFlags.NoTruncation, {
             trackSymbol: (symbol, declaration, meaning) => {
                 typeIsAccessible = typeIsAccessible && checker.isSymbolAccessible(symbol, declaration, meaning, /*shouldComputeAliasToMarkVisible*/ false).accessibility === SymbolAccessibility.Accessible;
+                return !typeIsAccessible;
             },
             reportInaccessibleThisError: notAccessible,
             reportPrivateInBaseOfClassExpression: notAccessible,

src/services/utilities.ts

@@ -0,0 +1,42 @@
+tests/cases/compiler/Api.ts(6,5): error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed.
+tests/cases/compiler/Api.ts(7,5): error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed.
+tests/cases/compiler/Api.ts(8,5): error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed.
+
+
+==== tests/cases/compiler/http-client.ts (0 errors) ====
+    type TPromise<ResolveType, RejectType = any> = Omit<Promise<ResolveType>, "then" | "catch"> & {
+        then<TResult1 = ResolveType, TResult2 = never>(
+            onfulfilled?: ((value: ResolveType) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+            onrejected?: ((reason: RejectType) => TResult2 | PromiseLike<TResult2>) | undefined | null,
+        ): TPromise<TResult1 | TResult2, RejectType>;
+        catch<TResult = never>(
+            onrejected?: ((reason: RejectType) => TResult | PromiseLike<TResult>) | undefined | null,
+        ): TPromise<ResolveType | TResult, RejectType>;
+    };
+    
+    export interface HttpResponse<D extends unknown, E extends unknown = unknown> extends Response {
+        data: D;
+        error: E;
+    }
+    
+    export class HttpClient<SecurityDataType = unknown> {
+        public request = <T = any, E = any>(): TPromise<HttpResponse<T, E>> => {
+            return '' as any;
+        };
+    }
+==== tests/cases/compiler/Api.ts (3 errors) ====
+    import { HttpClient } from "./http-client";
+    
+    export class Api<SecurityDataType = unknown> {
+        constructor(private http: HttpClient<SecurityDataType>) { }
+    
+        abc1 = () => this.http.request();
+        ~~~~
+!!! error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed.
+        abc2 = () => this.http.request();
+        ~~~~
+!!! error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed.
+        abc3 = () => this.http.request();
+        ~~~~
+!!! error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed.
+    }

tests/baselines/reference/declarationEmitPrivatePromiseLikeInterface.errors.txt

@@ -0,0 +1,77 @@
+//// [tests/cases/compiler/declarationEmitPrivatePromiseLikeInterface.ts] ////
+
+//// [http-client.ts]
+type TPromise<ResolveType, RejectType = any> = Omit<Promise<ResolveType>, "then" | "catch"> & {
+    then<TResult1 = ResolveType, TResult2 = never>(
+        onfulfilled?: ((value: ResolveType) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+        onrejected?: ((reason: RejectType) => TResult2 | PromiseLike<TResult2>) | undefined | null,
+    ): TPromise<TResult1 | TResult2, RejectType>;
+    catch<TResult = never>(
+        onrejected?: ((reason: RejectType) => TResult | PromiseLike<TResult>) | undefined | null,
+    ): TPromise<ResolveType | TResult, RejectType>;
+};
+
+export interface HttpResponse<D extends unknown, E extends unknown = unknown> extends Response {
+    data: D;
+    error: E;
+}
+
+export class HttpClient<SecurityDataType = unknown> {
+    public request = <T = any, E = any>(): TPromise<HttpResponse<T, E>> => {
+        return '' as any;
+    };
+}
+//// [Api.ts]
+import { HttpClient } from "./http-client";
+
+export class Api<SecurityDataType = unknown> {
+    constructor(private http: HttpClient<SecurityDataType>) { }
+
+    abc1 = () => this.http.request();
+    abc2 = () => this.http.request();
+    abc3 = () => this.http.request();
+}
+
+//// [http-client.js]
+"use strict";
+exports.__esModule = true;
+exports.HttpClient = void 0;
+var HttpClient = /** @class */ (function () {
+    function HttpClient() {
+        this.request = function () {
+            return '';
+        };
+    }
+    return HttpClient;
+}());
+exports.HttpClient = HttpClient;
+//// [Api.js]
+"use strict";
+exports.__esModule = true;
+exports.Api = void 0;
+var Api = /** @class */ (function () {
+    function Api(http) {
+        var _this = this;
+        this.http = http;
+        this.abc1 = function () { return _this.http.request(); };
+        this.abc2 = function () { return _this.http.request(); };
+        this.abc3 = function () { return _this.http.request(); };
+    }
+    return Api;
+}());
+exports.Api = Api;
+
+
+//// [http-client.d.ts]
+declare type TPromise<ResolveType, RejectType = any> = Omit<Promise<ResolveType>, "then" | "catch"> & {
+    then<TResult1 = ResolveType, TResult2 = never>(onfulfilled?: ((value: ResolveType) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: RejectType) => TResult2 | PromiseLike<TResult2>) | undefined | null): TPromise<TResult1 | TResult2, RejectType>;
+    catch<TResult = never>(onrejected?: ((reason: RejectType) => TResult | PromiseLike<TResult>) | undefined | null): TPromise<ResolveType | TResult, RejectType>;
+};
+export interface HttpResponse<D extends unknown, E extends unknown = unknown> extends Response {
+    data: D;
+    error: E;
+}
+export declare class HttpClient<SecurityDataType = unknown> {
+    request: <T = any, E = any>() => TPromise<HttpResponse<T, E>, any>;
+}
+export {};