[api-extractor] .d.ts rollup sometimes emits names that conflict with global names

[octogonz]

Consider this example:

import { Promise as MyPromise } from './file1';

export function f(p1: Promise<void>, p2: MyPromise<void>): void {
  // p1 is using the ambient Promise from the compiler runtime
  // p2 is using the declaration from file1, which happens to use the same name "Promise"
  // in that file
}

In the .d.ts rollup, p1 and p2 accidentally end up with the same type:

declare class Promise<T> {
    private x;
}

export declare function f(p1: Promise<void>, p2: Promise<void>): void;

This happens because the algorithm doesn't realize that Promise is a global name introduced by lib.es2015.promise.d.ts, which comes in via this part of tsconfig.json:

    "lib": [
      "es5",
      "scripthost",
      "es2015.collection",
      "es2015.promise",
      "es2015.iterable",
      "dom"
    ],

This is breaking @microsoft/sp-application-base.

@iclanton

[octogonz]

In typescript.d.ts I found this interface, which checks whether a name is global or not:

    interface PrintHandlers {
        /**
         * A hook used by the Printer when generating unique names to avoid collisions with
         * globally defined names that exist outside of the current source file.
         */
        hasGlobalName?(name: string): boolean;

However, it is a contract meant to be implemented by the caller of the Printer. Internally the compiler seems to implement it via the EmitResolver, which has this code:

namespace ts {
    . . .
    export function createTypeChecker(host: TypeCheckerHost, produceDiagnostics: boolean): TypeChecker {
        . . .
        const globals = createSymbolTable();
        . . .
        const checker: TypeChecker = {
            . . .
            hasGlobalName
            . . .
        };
        . . .
        return checker;
        . . .
        function hasGlobalName(name: string): boolean {
            return globals.has(escapeLeadingUnderscores(name));
        }

But when I try to use program.getTypeChecker() it complains that it was created with produceDiagnostics = false.

[octogonz]

The "es2015.promise" module can be found in the list of processed source files via this.program.getSourceFiles(), but these modules don't have symbols, so there's no "exports" that we can easily retrieve from them.

From any source file, you can enumerate Promise and Map and most other global names like this:

this.typeChecker.getSymbolsInScope(sourceFile, ts.SymbolFlags.Transient)

...however I'm pretty sure there exist global symbols that are not "transient", as well as "transient" symbols that are not global names.

The compiler docs don't say much about what "transient" actually means besides this, but it sounds like the wrong concept for what we need:

    export const enum SymbolFlags {
        . . .
        Transient               = 1 << 25,  // Transient symbol (created during type check)

@RyanCavanaugh @DanielRosenwasser any idea how to find the global names? For example, is there any example anywhere of someone implementing the PrintHandlers.hasGlobalName contract mentioned above?

[octogonz]

Okay, I found several internal APIs that can be combined together to reach hasGlobalName(): :-)

const typeChecker = (this.program as any).getDiagnosticsProducingTypeChecker();
const resolver = (typeChecker as any).getEmitResolver();
resolver.hasGlobalName('Promise'); // --> true

Is this a valid/safe solution?

[octogonz]

Hmm... the symbol table being queried by hasGlobalName() has 1,650 names in it... is that really correct?

Besides Promise, it also finds:

• Partial
• RTCStatsIceCandidateType
• SVGAnimatedInteger
• encodeURI
• eval
• it
• "https" (quotes included)
• "v8"

[RyanCavanaugh]

@octogonz that's correct. The global symbol table has everything you could reach from an unqualified position (Partial, encodeURI, etc) as well as all module names you could import without path qualification ("https", etc).

[octogonz]

@RyanCavanaugh Welcome back, BTW! 😄