From c52cc893899006d000e77ff7a691f08e5a09a95c Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Fri, 25 Aug 2017 13:44:35 -0700 Subject: [PATCH 1/2] Do not consider UMD alias symbols as visible within external modules in the symbol writer --- src/compiler/checker.ts | 5 + .../reference/exportAsNamespace.d.types | 2 +- ...mportShouldNotBeElidedInDeclarationEmit.js | 91 ++++++ ...ShouldNotBeElidedInDeclarationEmit.symbols | 257 +++++++++++++++++ ...rtShouldNotBeElidedInDeclarationEmit.types | 268 ++++++++++++++++++ .../reference/umd-augmentation-1.types | 2 +- .../reference/umd-augmentation-2.types | 2 +- .../reference/umd-augmentation-3.symbols | 2 +- .../reference/umd-augmentation-3.types | 4 +- .../reference/umd-augmentation-4.symbols | 2 +- .../reference/umd-augmentation-4.types | 4 +- tests/baselines/reference/umd1.types | 2 +- tests/baselines/reference/umd3.types | 2 +- tests/baselines/reference/umd4.types | 2 +- .../reference/umdGlobalConflict.types | 2 +- ...mportShouldNotBeElidedInDeclarationEmit.ts | 63 ++++ 16 files changed, 697 insertions(+), 13 deletions(-) create mode 100644 tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.js create mode 100644 tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.symbols create mode 100644 tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.types create mode 100644 tests/cases/compiler/importShouldNotBeElidedInDeclarationEmit.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 8f1f480874103..87e43cdd94558 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -2095,6 +2095,10 @@ namespace ts { canQualifySymbol(symbolFromSymbolTable, meaning); } + function isUMDExportSymbol(symbol: Symbol) { + return symbol && symbol.declarations && symbol.declarations[0] && isNamespaceExportDeclaration(symbol.declarations[0]); + } + function trySymbolTable(symbols: SymbolTable) { // If symbol is directly available by its name in the symbol table if (isAccessible(symbols.get(symbol.escapedName))) { @@ -2106,6 +2110,7 @@ namespace ts { if (symbolFromSymbolTable.flags & SymbolFlags.Alias && symbolFromSymbolTable.escapedName !== "export=" && !getDeclarationOfKind(symbolFromSymbolTable, SyntaxKind.ExportSpecifier) + && !(isUMDExportSymbol(symbolFromSymbolTable) && isExternalModule(getSourceFileOfNode(enclosingDeclaration))) // If `!useOnlyExternalAliasing`, we can use any type of alias to get the name && (!useOnlyExternalAliasing || some(symbolFromSymbolTable.declarations, isExternalModuleImportEqualsDeclaration))) { diff --git a/tests/baselines/reference/exportAsNamespace.d.types b/tests/baselines/reference/exportAsNamespace.d.types index 706857bf8ed0e..4952cb8863bc7 100644 --- a/tests/baselines/reference/exportAsNamespace.d.types +++ b/tests/baselines/reference/exportAsNamespace.d.types @@ -5,5 +5,5 @@ export var X; >X : any export as namespace N ->N : typeof N +>N : typeof "tests/cases/compiler/exportAsNamespace" diff --git a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.js b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.js new file mode 100644 index 0000000000000..af3ede0ca8649 --- /dev/null +++ b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.js @@ -0,0 +1,91 @@ +//// [tests/cases/compiler/importShouldNotBeElidedInDeclarationEmit.ts] //// + +//// [reselect.d.ts] +export as namespace Reselect; + +export type Selector = (state: S) => R; + +export type OutputSelector = Selector & { + resultFunc: C; + recomputations: () => number; + resetRecomputations: () => number; +}; + +export type ParametricSelector = (state: S, props: P, ...args: any[]) => R; + +export type OutputParametricSelector = ParametricSelector & { + resultFunc: C; + recomputations: () => number; + resetRecomputations: () => number; +}; + +/* one selector */ +export function createSelector( + selector: Selector, + combiner: (res: R1) => T, +): OutputSelector T>; +export function createSelector( + selector: ParametricSelector, + combiner: (res: R1) => T, +): OutputParametricSelector T>; + +/* two selectors */ +export function createSelector( + selector1: Selector, + selector2: Selector, + combiner: (res1: R1, res2: R2) => T, +): OutputSelector T>; +export function createSelector( + selector1: ParametricSelector, + selector2: ParametricSelector, + combiner: (res1: R1, res2: R2) => T, +): OutputParametricSelector T>; + +//// [index.ts] +import { createSelector } from "reselect"; +/* + * changing the import to + * import * as reselect from 'reselect'; + * and accessing reselect.createSelector fixes the issue +*/ +export interface State { + a: string; + b: number; +} +export const selector = createSelector( + state => state.a, + state => state.b, + (a, b) => { + return { + out: `${a}+${b}` + }; + } +); +selector({ a: "string", b: 5 }); + +//// [index.js] +"use strict"; +exports.__esModule = true; +var reselect_1 = require("reselect"); +exports.selector = reselect_1.createSelector(function (state) { return state.a; }, function (state) { return state.b; }, function (a, b) { + return { + out: a + "+" + b + }; +}); +exports.selector({ a: "string", b: 5 }); + + +//// [index.d.ts] +export interface State { + a: string; + b: number; +} +export declare const selector: ((state: State) => { + out: string; +}) & { + resultFunc: (res1: string, res2: number) => { + out: string; + }; + recomputations: () => number; + resetRecomputations: () => number; +}; diff --git a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.symbols b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.symbols new file mode 100644 index 0000000000000..ce7e83ea6cd6e --- /dev/null +++ b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.symbols @@ -0,0 +1,257 @@ +=== tests/cases/compiler/node_modules/reselect.d.ts === +export as namespace Reselect; +>Reselect : Symbol(Reselect, Decl(reselect.d.ts, 0, 0)) + +export type Selector = (state: S) => R; +>Selector : Symbol(Selector, Decl(reselect.d.ts, 0, 29)) +>S : Symbol(S, Decl(reselect.d.ts, 2, 21)) +>R : Symbol(R, Decl(reselect.d.ts, 2, 23)) +>state : Symbol(state, Decl(reselect.d.ts, 2, 30)) +>S : Symbol(S, Decl(reselect.d.ts, 2, 21)) +>R : Symbol(R, Decl(reselect.d.ts, 2, 23)) + +export type OutputSelector = Selector & { +>OutputSelector : Symbol(OutputSelector, Decl(reselect.d.ts, 2, 45)) +>S : Symbol(S, Decl(reselect.d.ts, 4, 27)) +>R : Symbol(R, Decl(reselect.d.ts, 4, 29)) +>C : Symbol(C, Decl(reselect.d.ts, 4, 32)) +>Selector : Symbol(Selector, Decl(reselect.d.ts, 0, 29)) +>S : Symbol(S, Decl(reselect.d.ts, 4, 27)) +>R : Symbol(R, Decl(reselect.d.ts, 4, 29)) + + resultFunc: C; +>resultFunc : Symbol(resultFunc, Decl(reselect.d.ts, 4, 56)) +>C : Symbol(C, Decl(reselect.d.ts, 4, 32)) + + recomputations: () => number; +>recomputations : Symbol(recomputations, Decl(reselect.d.ts, 5, 16)) + + resetRecomputations: () => number; +>resetRecomputations : Symbol(resetRecomputations, Decl(reselect.d.ts, 6, 31)) + +}; + +export type ParametricSelector = (state: S, props: P, ...args: any[]) => R; +>ParametricSelector : Symbol(ParametricSelector, Decl(reselect.d.ts, 8, 2)) +>S : Symbol(S, Decl(reselect.d.ts, 10, 31)) +>P : Symbol(P, Decl(reselect.d.ts, 10, 33)) +>R : Symbol(R, Decl(reselect.d.ts, 10, 36)) +>state : Symbol(state, Decl(reselect.d.ts, 10, 43)) +>S : Symbol(S, Decl(reselect.d.ts, 10, 31)) +>props : Symbol(props, Decl(reselect.d.ts, 10, 52)) +>P : Symbol(P, Decl(reselect.d.ts, 10, 33)) +>args : Symbol(args, Decl(reselect.d.ts, 10, 62)) +>R : Symbol(R, Decl(reselect.d.ts, 10, 36)) + +export type OutputParametricSelector = ParametricSelector & { +>OutputParametricSelector : Symbol(OutputParametricSelector, Decl(reselect.d.ts, 10, 84)) +>S : Symbol(S, Decl(reselect.d.ts, 12, 37)) +>P : Symbol(P, Decl(reselect.d.ts, 12, 39)) +>R : Symbol(R, Decl(reselect.d.ts, 12, 42)) +>C : Symbol(C, Decl(reselect.d.ts, 12, 45)) +>ParametricSelector : Symbol(ParametricSelector, Decl(reselect.d.ts, 8, 2)) +>S : Symbol(S, Decl(reselect.d.ts, 12, 37)) +>P : Symbol(P, Decl(reselect.d.ts, 12, 39)) +>R : Symbol(R, Decl(reselect.d.ts, 12, 42)) + + resultFunc: C; +>resultFunc : Symbol(resultFunc, Decl(reselect.d.ts, 12, 82)) +>C : Symbol(C, Decl(reselect.d.ts, 12, 45)) + + recomputations: () => number; +>recomputations : Symbol(recomputations, Decl(reselect.d.ts, 13, 16)) + + resetRecomputations: () => number; +>resetRecomputations : Symbol(resetRecomputations, Decl(reselect.d.ts, 14, 31)) + +}; + +/* one selector */ +export function createSelector( +>createSelector : Symbol(createSelector, Decl(reselect.d.ts, 16, 2), Decl(reselect.d.ts, 22, 40), Decl(reselect.d.ts, 26, 53), Decl(reselect.d.ts, 33, 51)) +>S : Symbol(S, Decl(reselect.d.ts, 19, 31)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 19, 33)) +>T : Symbol(T, Decl(reselect.d.ts, 19, 37)) + + selector: Selector, +>selector : Symbol(selector, Decl(reselect.d.ts, 19, 41)) +>Selector : Symbol(Selector, Decl(reselect.d.ts, 0, 29)) +>S : Symbol(S, Decl(reselect.d.ts, 19, 31)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 19, 33)) + + combiner: (res: R1) => T, +>combiner : Symbol(combiner, Decl(reselect.d.ts, 20, 30)) +>res : Symbol(res, Decl(reselect.d.ts, 21, 15)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 19, 33)) +>T : Symbol(T, Decl(reselect.d.ts, 19, 37)) + +): OutputSelector T>; +>OutputSelector : Symbol(OutputSelector, Decl(reselect.d.ts, 2, 45)) +>S : Symbol(S, Decl(reselect.d.ts, 19, 31)) +>T : Symbol(T, Decl(reselect.d.ts, 19, 37)) +>res : Symbol(res, Decl(reselect.d.ts, 22, 25)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 19, 33)) +>T : Symbol(T, Decl(reselect.d.ts, 19, 37)) + +export function createSelector( +>createSelector : Symbol(createSelector, Decl(reselect.d.ts, 16, 2), Decl(reselect.d.ts, 22, 40), Decl(reselect.d.ts, 26, 53), Decl(reselect.d.ts, 33, 51)) +>S : Symbol(S, Decl(reselect.d.ts, 23, 31)) +>P : Symbol(P, Decl(reselect.d.ts, 23, 33)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 23, 36)) +>T : Symbol(T, Decl(reselect.d.ts, 23, 40)) + + selector: ParametricSelector, +>selector : Symbol(selector, Decl(reselect.d.ts, 23, 44)) +>ParametricSelector : Symbol(ParametricSelector, Decl(reselect.d.ts, 8, 2)) +>S : Symbol(S, Decl(reselect.d.ts, 23, 31)) +>P : Symbol(P, Decl(reselect.d.ts, 23, 33)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 23, 36)) + + combiner: (res: R1) => T, +>combiner : Symbol(combiner, Decl(reselect.d.ts, 24, 43)) +>res : Symbol(res, Decl(reselect.d.ts, 25, 15)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 23, 36)) +>T : Symbol(T, Decl(reselect.d.ts, 23, 40)) + +): OutputParametricSelector T>; +>OutputParametricSelector : Symbol(OutputParametricSelector, Decl(reselect.d.ts, 10, 84)) +>S : Symbol(S, Decl(reselect.d.ts, 23, 31)) +>P : Symbol(P, Decl(reselect.d.ts, 23, 33)) +>T : Symbol(T, Decl(reselect.d.ts, 23, 40)) +>res : Symbol(res, Decl(reselect.d.ts, 26, 38)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 23, 36)) +>T : Symbol(T, Decl(reselect.d.ts, 23, 40)) + +/* two selectors */ +export function createSelector( +>createSelector : Symbol(createSelector, Decl(reselect.d.ts, 16, 2), Decl(reselect.d.ts, 22, 40), Decl(reselect.d.ts, 26, 53), Decl(reselect.d.ts, 33, 51)) +>S : Symbol(S, Decl(reselect.d.ts, 29, 31)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 29, 33)) +>R2 : Symbol(R2, Decl(reselect.d.ts, 29, 37)) +>T : Symbol(T, Decl(reselect.d.ts, 29, 41)) + + selector1: Selector, +>selector1 : Symbol(selector1, Decl(reselect.d.ts, 29, 45)) +>Selector : Symbol(Selector, Decl(reselect.d.ts, 0, 29)) +>S : Symbol(S, Decl(reselect.d.ts, 29, 31)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 29, 33)) + + selector2: Selector, +>selector2 : Symbol(selector2, Decl(reselect.d.ts, 30, 31)) +>Selector : Symbol(Selector, Decl(reselect.d.ts, 0, 29)) +>S : Symbol(S, Decl(reselect.d.ts, 29, 31)) +>R2 : Symbol(R2, Decl(reselect.d.ts, 29, 37)) + + combiner: (res1: R1, res2: R2) => T, +>combiner : Symbol(combiner, Decl(reselect.d.ts, 31, 31)) +>res1 : Symbol(res1, Decl(reselect.d.ts, 32, 15)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 29, 33)) +>res2 : Symbol(res2, Decl(reselect.d.ts, 32, 24)) +>R2 : Symbol(R2, Decl(reselect.d.ts, 29, 37)) +>T : Symbol(T, Decl(reselect.d.ts, 29, 41)) + +): OutputSelector T>; +>OutputSelector : Symbol(OutputSelector, Decl(reselect.d.ts, 2, 45)) +>S : Symbol(S, Decl(reselect.d.ts, 29, 31)) +>T : Symbol(T, Decl(reselect.d.ts, 29, 41)) +>res1 : Symbol(res1, Decl(reselect.d.ts, 33, 25)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 29, 33)) +>res2 : Symbol(res2, Decl(reselect.d.ts, 33, 34)) +>R2 : Symbol(R2, Decl(reselect.d.ts, 29, 37)) +>T : Symbol(T, Decl(reselect.d.ts, 29, 41)) + +export function createSelector( +>createSelector : Symbol(createSelector, Decl(reselect.d.ts, 16, 2), Decl(reselect.d.ts, 22, 40), Decl(reselect.d.ts, 26, 53), Decl(reselect.d.ts, 33, 51)) +>S : Symbol(S, Decl(reselect.d.ts, 34, 31)) +>P : Symbol(P, Decl(reselect.d.ts, 34, 33)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 34, 36)) +>R2 : Symbol(R2, Decl(reselect.d.ts, 34, 40)) +>T : Symbol(T, Decl(reselect.d.ts, 34, 44)) + + selector1: ParametricSelector, +>selector1 : Symbol(selector1, Decl(reselect.d.ts, 34, 48)) +>ParametricSelector : Symbol(ParametricSelector, Decl(reselect.d.ts, 8, 2)) +>S : Symbol(S, Decl(reselect.d.ts, 34, 31)) +>P : Symbol(P, Decl(reselect.d.ts, 34, 33)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 34, 36)) + + selector2: ParametricSelector, +>selector2 : Symbol(selector2, Decl(reselect.d.ts, 35, 44)) +>ParametricSelector : Symbol(ParametricSelector, Decl(reselect.d.ts, 8, 2)) +>S : Symbol(S, Decl(reselect.d.ts, 34, 31)) +>P : Symbol(P, Decl(reselect.d.ts, 34, 33)) +>R2 : Symbol(R2, Decl(reselect.d.ts, 34, 40)) + + combiner: (res1: R1, res2: R2) => T, +>combiner : Symbol(combiner, Decl(reselect.d.ts, 36, 44)) +>res1 : Symbol(res1, Decl(reselect.d.ts, 37, 15)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 34, 36)) +>res2 : Symbol(res2, Decl(reselect.d.ts, 37, 24)) +>R2 : Symbol(R2, Decl(reselect.d.ts, 34, 40)) +>T : Symbol(T, Decl(reselect.d.ts, 34, 44)) + +): OutputParametricSelector T>; +>OutputParametricSelector : Symbol(OutputParametricSelector, Decl(reselect.d.ts, 10, 84)) +>S : Symbol(S, Decl(reselect.d.ts, 34, 31)) +>P : Symbol(P, Decl(reselect.d.ts, 34, 33)) +>T : Symbol(T, Decl(reselect.d.ts, 34, 44)) +>res1 : Symbol(res1, Decl(reselect.d.ts, 38, 38)) +>R1 : Symbol(R1, Decl(reselect.d.ts, 34, 36)) +>res2 : Symbol(res2, Decl(reselect.d.ts, 38, 47)) +>R2 : Symbol(R2, Decl(reselect.d.ts, 34, 40)) +>T : Symbol(T, Decl(reselect.d.ts, 34, 44)) + +=== tests/cases/compiler/index.ts === +import { createSelector } from "reselect"; +>createSelector : Symbol(createSelector, Decl(index.ts, 0, 8)) + +/* + * changing the import to + * import * as reselect from 'reselect'; + * and accessing reselect.createSelector fixes the issue +*/ +export interface State { +>State : Symbol(State, Decl(index.ts, 0, 42)) + + a: string; +>a : Symbol(State.a, Decl(index.ts, 6, 24)) + + b: number; +>b : Symbol(State.b, Decl(index.ts, 7, 14)) +} +export const selector = createSelector( +>selector : Symbol(selector, Decl(index.ts, 10, 12)) +>createSelector : Symbol(createSelector, Decl(index.ts, 0, 8)) +>State : Symbol(State, Decl(index.ts, 0, 42)) +>out : Symbol(out, Decl(index.ts, 10, 63)) + + state => state.a, +>state : Symbol(state, Decl(index.ts, 10, 79)) +>state.a : Symbol(State.a, Decl(index.ts, 6, 24)) +>state : Symbol(state, Decl(index.ts, 10, 79)) +>a : Symbol(State.a, Decl(index.ts, 6, 24)) + + state => state.b, +>state : Symbol(state, Decl(index.ts, 11, 21)) +>state.b : Symbol(State.b, Decl(index.ts, 7, 14)) +>state : Symbol(state, Decl(index.ts, 11, 21)) +>b : Symbol(State.b, Decl(index.ts, 7, 14)) + + (a, b) => { +>a : Symbol(a, Decl(index.ts, 13, 5)) +>b : Symbol(b, Decl(index.ts, 13, 7)) + + return { + out: `${a}+${b}` +>out : Symbol(out, Decl(index.ts, 14, 16)) +>a : Symbol(a, Decl(index.ts, 13, 5)) +>b : Symbol(b, Decl(index.ts, 13, 7)) + + }; + } +); +selector({ a: "string", b: 5 }); +>selector : Symbol(selector, Decl(index.ts, 10, 12)) +>a : Symbol(a, Decl(index.ts, 19, 10)) +>b : Symbol(b, Decl(index.ts, 19, 23)) + diff --git a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.types b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.types new file mode 100644 index 0000000000000..cf154a619c7eb --- /dev/null +++ b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.types @@ -0,0 +1,268 @@ +=== tests/cases/compiler/node_modules/reselect.d.ts === +export as namespace Reselect; +>Reselect : typeof "tests/cases/compiler/node_modules/reselect" + +export type Selector = (state: S) => R; +>Selector : Selector +>S : S +>R : R +>state : S +>S : S +>R : R + +export type OutputSelector = Selector & { +>OutputSelector : OutputSelector +>S : S +>R : R +>C : C +>Selector : Selector +>S : S +>R : R + + resultFunc: C; +>resultFunc : C +>C : C + + recomputations: () => number; +>recomputations : () => number + + resetRecomputations: () => number; +>resetRecomputations : () => number + +}; + +export type ParametricSelector = (state: S, props: P, ...args: any[]) => R; +>ParametricSelector : ParametricSelector +>S : S +>P : P +>R : R +>state : S +>S : S +>props : P +>P : P +>args : any[] +>R : R + +export type OutputParametricSelector = ParametricSelector & { +>OutputParametricSelector : OutputParametricSelector +>S : S +>P : P +>R : R +>C : C +>ParametricSelector : ParametricSelector +>S : S +>P : P +>R : R + + resultFunc: C; +>resultFunc : C +>C : C + + recomputations: () => number; +>recomputations : () => number + + resetRecomputations: () => number; +>resetRecomputations : () => number + +}; + +/* one selector */ +export function createSelector( +>createSelector : { (selector: Selector, combiner: (res: R1) => T): OutputSelector T>; (selector: ParametricSelector, combiner: (res: R1) => T): OutputParametricSelector T>; (selector1: Selector, selector2: Selector, combiner: (res1: R1, res2: R2) => T): OutputSelector T>; (selector1: ParametricSelector, selector2: ParametricSelector, combiner: (res1: R1, res2: R2) => T): OutputParametricSelector T>; } +>S : S +>R1 : R1 +>T : T + + selector: Selector, +>selector : Selector +>Selector : Selector +>S : S +>R1 : R1 + + combiner: (res: R1) => T, +>combiner : (res: R1) => T +>res : R1 +>R1 : R1 +>T : T + +): OutputSelector T>; +>OutputSelector : OutputSelector +>S : S +>T : T +>res : R1 +>R1 : R1 +>T : T + +export function createSelector( +>createSelector : { (selector: Selector, combiner: (res: R1) => T): OutputSelector T>; (selector: ParametricSelector, combiner: (res: R1) => T): OutputParametricSelector T>; (selector1: Selector, selector2: Selector, combiner: (res1: R1, res2: R2) => T): OutputSelector T>; (selector1: ParametricSelector, selector2: ParametricSelector, combiner: (res1: R1, res2: R2) => T): OutputParametricSelector T>; } +>S : S +>P : P +>R1 : R1 +>T : T + + selector: ParametricSelector, +>selector : ParametricSelector +>ParametricSelector : ParametricSelector +>S : S +>P : P +>R1 : R1 + + combiner: (res: R1) => T, +>combiner : (res: R1) => T +>res : R1 +>R1 : R1 +>T : T + +): OutputParametricSelector T>; +>OutputParametricSelector : OutputParametricSelector +>S : S +>P : P +>T : T +>res : R1 +>R1 : R1 +>T : T + +/* two selectors */ +export function createSelector( +>createSelector : { (selector: Selector, combiner: (res: R1) => T): OutputSelector T>; (selector: ParametricSelector, combiner: (res: R1) => T): OutputParametricSelector T>; (selector1: Selector, selector2: Selector, combiner: (res1: R1, res2: R2) => T): OutputSelector T>; (selector1: ParametricSelector, selector2: ParametricSelector, combiner: (res1: R1, res2: R2) => T): OutputParametricSelector T>; } +>S : S +>R1 : R1 +>R2 : R2 +>T : T + + selector1: Selector, +>selector1 : Selector +>Selector : Selector +>S : S +>R1 : R1 + + selector2: Selector, +>selector2 : Selector +>Selector : Selector +>S : S +>R2 : R2 + + combiner: (res1: R1, res2: R2) => T, +>combiner : (res1: R1, res2: R2) => T +>res1 : R1 +>R1 : R1 +>res2 : R2 +>R2 : R2 +>T : T + +): OutputSelector T>; +>OutputSelector : OutputSelector +>S : S +>T : T +>res1 : R1 +>R1 : R1 +>res2 : R2 +>R2 : R2 +>T : T + +export function createSelector( +>createSelector : { (selector: Selector, combiner: (res: R1) => T): OutputSelector T>; (selector: ParametricSelector, combiner: (res: R1) => T): OutputParametricSelector T>; (selector1: Selector, selector2: Selector, combiner: (res1: R1, res2: R2) => T): OutputSelector T>; (selector1: ParametricSelector, selector2: ParametricSelector, combiner: (res1: R1, res2: R2) => T): OutputParametricSelector T>; } +>S : S +>P : P +>R1 : R1 +>R2 : R2 +>T : T + + selector1: ParametricSelector, +>selector1 : ParametricSelector +>ParametricSelector : ParametricSelector +>S : S +>P : P +>R1 : R1 + + selector2: ParametricSelector, +>selector2 : ParametricSelector +>ParametricSelector : ParametricSelector +>S : S +>P : P +>R2 : R2 + + combiner: (res1: R1, res2: R2) => T, +>combiner : (res1: R1, res2: R2) => T +>res1 : R1 +>R1 : R1 +>res2 : R2 +>R2 : R2 +>T : T + +): OutputParametricSelector T>; +>OutputParametricSelector : OutputParametricSelector +>S : S +>P : P +>T : T +>res1 : R1 +>R1 : R1 +>res2 : R2 +>R2 : R2 +>T : T + +=== tests/cases/compiler/index.ts === +import { createSelector } from "reselect"; +>createSelector : { (selector: (state: S) => R1, combiner: (res: R1) => T): ((state: S) => T) & { resultFunc: (res: R1) => T; recomputations: () => number; resetRecomputations: () => number; }; (selector: (state: S, props: P, ...args: any[]) => R1, combiner: (res: R1) => T): ((state: S, props: P, ...args: any[]) => T) & { resultFunc: (res: R1) => T; recomputations: () => number; resetRecomputations: () => number; }; (selector1: (state: S) => R1, selector2: (state: S) => R2, combiner: (res1: R1, res2: R2) => T): ((state: S) => T) & { resultFunc: (res1: R1, res2: R2) => T; recomputations: () => number; resetRecomputations: () => number; }; (selector1: (state: S, props: P, ...args: any[]) => R1, selector2: (state: S, props: P, ...args: any[]) => R2, combiner: (res1: R1, res2: R2) => T): ((state: S, props: P, ...args: any[]) => T) & { resultFunc: (res1: R1, res2: R2) => T; recomputations: () => number; resetRecomputations: () => number; }; } + +/* + * changing the import to + * import * as reselect from 'reselect'; + * and accessing reselect.createSelector fixes the issue +*/ +export interface State { +>State : State + + a: string; +>a : string + + b: number; +>b : number +} +export const selector = createSelector( +>selector : ((state: State) => { out: string; }) & { resultFunc: (res1: string, res2: number) => { out: string; }; recomputations: () => number; resetRecomputations: () => number; } +>createSelector( state => state.a, state => state.b, (a, b) => { return { out: `${a}+${b}` }; }) : ((state: State) => { out: string; }) & { resultFunc: (res1: string, res2: number) => { out: string; }; recomputations: () => number; resetRecomputations: () => number; } +>createSelector : { (selector: (state: S) => R1, combiner: (res: R1) => T): ((state: S) => T) & { resultFunc: (res: R1) => T; recomputations: () => number; resetRecomputations: () => number; }; (selector: (state: S, props: P, ...args: any[]) => R1, combiner: (res: R1) => T): ((state: S, props: P, ...args: any[]) => T) & { resultFunc: (res: R1) => T; recomputations: () => number; resetRecomputations: () => number; }; (selector1: (state: S) => R1, selector2: (state: S) => R2, combiner: (res1: R1, res2: R2) => T): ((state: S) => T) & { resultFunc: (res1: R1, res2: R2) => T; recomputations: () => number; resetRecomputations: () => number; }; (selector1: (state: S, props: P, ...args: any[]) => R1, selector2: (state: S, props: P, ...args: any[]) => R2, combiner: (res1: R1, res2: R2) => T): ((state: S, props: P, ...args: any[]) => T) & { resultFunc: (res1: R1, res2: R2) => T; recomputations: () => number; resetRecomputations: () => number; }; } +>State : State +>out : string + + state => state.a, +>state => state.a : (state: State) => string +>state : State +>state.a : string +>state : State +>a : string + + state => state.b, +>state => state.b : (state: State) => number +>state : State +>state.b : number +>state : State +>b : number + + (a, b) => { +>(a, b) => { return { out: `${a}+${b}` }; } : (a: string, b: number) => { out: string; } +>a : string +>b : number + + return { +>{ out: `${a}+${b}` } : { out: string; } + + out: `${a}+${b}` +>out : string +>`${a}+${b}` : string +>a : string +>b : number + + }; + } +); +selector({ a: "string", b: 5 }); +>selector({ a: "string", b: 5 }) : { out: string; } +>selector : ((state: State) => { out: string; }) & { resultFunc: (res1: string, res2: number) => { out: string; }; recomputations: () => number; resetRecomputations: () => number; } +>{ a: "string", b: 5 } : { a: string; b: number; } +>a : string +>"string" : "string" +>b : number +>5 : 5 + diff --git a/tests/baselines/reference/umd-augmentation-1.types b/tests/baselines/reference/umd-augmentation-1.types index 5324e58f68e97..9d89e0c4537c5 100644 --- a/tests/baselines/reference/umd-augmentation-1.types +++ b/tests/baselines/reference/umd-augmentation-1.types @@ -47,7 +47,7 @@ var t = p.x; === tests/cases/conformance/externalModules/node_modules/math2d/index.d.ts === export as namespace Math2d; ->Math2d : typeof Math2d +>Math2d : typeof "tests/cases/conformance/externalModules/node_modules/math2d/index" export interface Point { >Point : Point diff --git a/tests/baselines/reference/umd-augmentation-2.types b/tests/baselines/reference/umd-augmentation-2.types index 4ead8d611cabc..b8d04ecd643d3 100644 --- a/tests/baselines/reference/umd-augmentation-2.types +++ b/tests/baselines/reference/umd-augmentation-2.types @@ -45,7 +45,7 @@ var t = p.x; === tests/cases/conformance/externalModules/node_modules/math2d/index.d.ts === export as namespace Math2d; ->Math2d : typeof Math2d +>Math2d : typeof "tests/cases/conformance/externalModules/node_modules/math2d/index" export interface Point { >Point : Point diff --git a/tests/baselines/reference/umd-augmentation-3.symbols b/tests/baselines/reference/umd-augmentation-3.symbols index acb2f471faf07..7cbe3ac803bad 100644 --- a/tests/baselines/reference/umd-augmentation-3.symbols +++ b/tests/baselines/reference/umd-augmentation-3.symbols @@ -44,7 +44,7 @@ export = M2D; >M2D : Symbol(M2D, Decl(index.d.ts, 2, 13)) declare namespace M2D { ->M2D : Symbol(Math2d, Decl(index.d.ts, 2, 13), Decl(math2d-augment.d.ts, 0, 33)) +>M2D : Symbol(M2D, Decl(index.d.ts, 2, 13), Decl(math2d-augment.d.ts, 0, 33)) interface Point { >Point : Symbol(Point, Decl(index.d.ts, 4, 23)) diff --git a/tests/baselines/reference/umd-augmentation-3.types b/tests/baselines/reference/umd-augmentation-3.types index 4802d159e1838..5efafd780a01a 100644 --- a/tests/baselines/reference/umd-augmentation-3.types +++ b/tests/baselines/reference/umd-augmentation-3.types @@ -47,13 +47,13 @@ var t = p.x; === tests/cases/conformance/externalModules/node_modules/math2d/index.d.ts === export as namespace Math2d; ->Math2d : typeof Math2d +>Math2d : typeof M2D export = M2D; >M2D : typeof M2D declare namespace M2D { ->M2D : typeof Math2d +>M2D : typeof M2D interface Point { >Point : Point diff --git a/tests/baselines/reference/umd-augmentation-4.symbols b/tests/baselines/reference/umd-augmentation-4.symbols index 12696ab51f70e..eabb2e1589870 100644 --- a/tests/baselines/reference/umd-augmentation-4.symbols +++ b/tests/baselines/reference/umd-augmentation-4.symbols @@ -42,7 +42,7 @@ export = M2D; >M2D : Symbol(M2D, Decl(index.d.ts, 2, 13)) declare namespace M2D { ->M2D : Symbol(Math2d, Decl(index.d.ts, 2, 13), Decl(math2d-augment.d.ts, 0, 33)) +>M2D : Symbol(M2D, Decl(index.d.ts, 2, 13), Decl(math2d-augment.d.ts, 0, 33)) interface Point { >Point : Symbol(Point, Decl(index.d.ts, 4, 23)) diff --git a/tests/baselines/reference/umd-augmentation-4.types b/tests/baselines/reference/umd-augmentation-4.types index 324de3841833e..f71928f5afcd6 100644 --- a/tests/baselines/reference/umd-augmentation-4.types +++ b/tests/baselines/reference/umd-augmentation-4.types @@ -45,13 +45,13 @@ var t = p.x; === tests/cases/conformance/externalModules/node_modules/math2d/index.d.ts === export as namespace Math2d; ->Math2d : typeof Math2d +>Math2d : typeof M2D export = M2D; >M2D : typeof M2D declare namespace M2D { ->M2D : typeof Math2d +>M2D : typeof M2D interface Point { >Point : Point diff --git a/tests/baselines/reference/umd1.types b/tests/baselines/reference/umd1.types index 9ccc0d2cd8e2f..b84aaf3ad7031 100644 --- a/tests/baselines/reference/umd1.types +++ b/tests/baselines/reference/umd1.types @@ -30,5 +30,5 @@ export interface Thing { n: typeof x } >x : number export as namespace Foo; ->Foo : typeof Foo +>Foo : typeof "tests/cases/conformance/externalModules/foo" diff --git a/tests/baselines/reference/umd3.types b/tests/baselines/reference/umd3.types index ab7978545ba05..ef54806a174e9 100644 --- a/tests/baselines/reference/umd3.types +++ b/tests/baselines/reference/umd3.types @@ -32,5 +32,5 @@ export interface Thing { n: typeof x } >x : number export as namespace Foo; ->Foo : typeof Foo +>Foo : typeof "tests/cases/conformance/externalModules/foo" diff --git a/tests/baselines/reference/umd4.types b/tests/baselines/reference/umd4.types index c9144af7a18be..3b6ebfa6ca78e 100644 --- a/tests/baselines/reference/umd4.types +++ b/tests/baselines/reference/umd4.types @@ -32,5 +32,5 @@ export interface Thing { n: typeof x } >x : number export as namespace Foo; ->Foo : typeof Foo +>Foo : typeof "tests/cases/conformance/externalModules/foo" diff --git a/tests/baselines/reference/umdGlobalConflict.types b/tests/baselines/reference/umdGlobalConflict.types index d23d42e702a80..0bb26b47918bc 100644 --- a/tests/baselines/reference/umdGlobalConflict.types +++ b/tests/baselines/reference/umdGlobalConflict.types @@ -1,6 +1,6 @@ === tests/cases/compiler/v1/index.d.ts === export as namespace Alpha; ->Alpha : typeof Alpha +>Alpha : typeof "tests/cases/compiler/v1/index" export var x: string; >x : string diff --git a/tests/cases/compiler/importShouldNotBeElidedInDeclarationEmit.ts b/tests/cases/compiler/importShouldNotBeElidedInDeclarationEmit.ts new file mode 100644 index 0000000000000..0feb15a4b56ce --- /dev/null +++ b/tests/cases/compiler/importShouldNotBeElidedInDeclarationEmit.ts @@ -0,0 +1,63 @@ +// @declaration: true +// @filename: node_modules/reselect.d.ts +export as namespace Reselect; + +export type Selector = (state: S) => R; + +export type OutputSelector = Selector & { + resultFunc: C; + recomputations: () => number; + resetRecomputations: () => number; +}; + +export type ParametricSelector = (state: S, props: P, ...args: any[]) => R; + +export type OutputParametricSelector = ParametricSelector & { + resultFunc: C; + recomputations: () => number; + resetRecomputations: () => number; +}; + +/* one selector */ +export function createSelector( + selector: Selector, + combiner: (res: R1) => T, +): OutputSelector T>; +export function createSelector( + selector: ParametricSelector, + combiner: (res: R1) => T, +): OutputParametricSelector T>; + +/* two selectors */ +export function createSelector( + selector1: Selector, + selector2: Selector, + combiner: (res1: R1, res2: R2) => T, +): OutputSelector T>; +export function createSelector( + selector1: ParametricSelector, + selector2: ParametricSelector, + combiner: (res1: R1, res2: R2) => T, +): OutputParametricSelector T>; + +// @filename: index.ts +import { createSelector } from "reselect"; +/* + * changing the import to + * import * as reselect from 'reselect'; + * and accessing reselect.createSelector fixes the issue +*/ +export interface State { + a: string; + b: number; +} +export const selector = createSelector( + state => state.a, + state => state.b, + (a, b) => { + return { + out: `${a}+${b}` + }; + } +); +selector({ a: "string", b: 5 }); \ No newline at end of file From e0ae4b40c106a736cba76ea3dc67496bf896292c Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Fri, 25 Aug 2017 17:28:56 -0700 Subject: [PATCH 2/2] Minimal repro --- ...mportShouldNotBeElidedInDeclarationEmit.js | 91 +----- ...ShouldNotBeElidedInDeclarationEmit.symbols | 266 +---------------- ...rtShouldNotBeElidedInDeclarationEmit.types | 278 ++---------------- ...mportShouldNotBeElidedInDeclarationEmit.ts | 67 +---- 4 files changed, 54 insertions(+), 648 deletions(-) diff --git a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.js b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.js index af3ede0ca8649..a1316dbdd4640 100644 --- a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.js +++ b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.js @@ -1,91 +1,26 @@ //// [tests/cases/compiler/importShouldNotBeElidedInDeclarationEmit.ts] //// -//// [reselect.d.ts] -export as namespace Reselect; +//// [umd.d.ts] +export as namespace UMD; -export type Selector = (state: S) => R; - -export type OutputSelector = Selector & { - resultFunc: C; - recomputations: () => number; - resetRecomputations: () => number; -}; - -export type ParametricSelector = (state: S, props: P, ...args: any[]) => R; - -export type OutputParametricSelector = ParametricSelector & { - resultFunc: C; - recomputations: () => number; - resetRecomputations: () => number; -}; - -/* one selector */ -export function createSelector( - selector: Selector, - combiner: (res: R1) => T, -): OutputSelector T>; -export function createSelector( - selector: ParametricSelector, - combiner: (res: R1) => T, -): OutputParametricSelector T>; +export type Thing = { + a: number; +} -/* two selectors */ -export function createSelector( - selector1: Selector, - selector2: Selector, - combiner: (res1: R1, res2: R2) => T, -): OutputSelector T>; -export function createSelector( - selector1: ParametricSelector, - selector2: ParametricSelector, - combiner: (res1: R1, res2: R2) => T, -): OutputParametricSelector T>; - +export declare function makeThing(): Thing; //// [index.ts] -import { createSelector } from "reselect"; -/* - * changing the import to - * import * as reselect from 'reselect'; - * and accessing reselect.createSelector fixes the issue -*/ -export interface State { - a: string; - b: number; -} -export const selector = createSelector( - state => state.a, - state => state.b, - (a, b) => { - return { - out: `${a}+${b}` - }; - } -); -selector({ a: "string", b: 5 }); +import { makeThing } from "umd"; +export const thing = makeThing(); + //// [index.js] "use strict"; exports.__esModule = true; -var reselect_1 = require("reselect"); -exports.selector = reselect_1.createSelector(function (state) { return state.a; }, function (state) { return state.b; }, function (a, b) { - return { - out: a + "+" + b - }; -}); -exports.selector({ a: "string", b: 5 }); +var umd_1 = require("umd"); +exports.thing = umd_1.makeThing(); //// [index.d.ts] -export interface State { - a: string; - b: number; -} -export declare const selector: ((state: State) => { - out: string; -}) & { - resultFunc: (res1: string, res2: number) => { - out: string; - }; - recomputations: () => number; - resetRecomputations: () => number; +export declare const thing: { + a: number; }; diff --git a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.symbols b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.symbols index ce7e83ea6cd6e..4ac0f4928b0c1 100644 --- a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.symbols +++ b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.symbols @@ -1,257 +1,23 @@ -=== tests/cases/compiler/node_modules/reselect.d.ts === -export as namespace Reselect; ->Reselect : Symbol(Reselect, Decl(reselect.d.ts, 0, 0)) +=== tests/cases/compiler/node_modules/umd.d.ts === +export as namespace UMD; +>UMD : Symbol(UMD, Decl(umd.d.ts, 0, 0)) -export type Selector = (state: S) => R; ->Selector : Symbol(Selector, Decl(reselect.d.ts, 0, 29)) ->S : Symbol(S, Decl(reselect.d.ts, 2, 21)) ->R : Symbol(R, Decl(reselect.d.ts, 2, 23)) ->state : Symbol(state, Decl(reselect.d.ts, 2, 30)) ->S : Symbol(S, Decl(reselect.d.ts, 2, 21)) ->R : Symbol(R, Decl(reselect.d.ts, 2, 23)) +export type Thing = { +>Thing : Symbol(Thing, Decl(umd.d.ts, 0, 24)) -export type OutputSelector = Selector & { ->OutputSelector : Symbol(OutputSelector, Decl(reselect.d.ts, 2, 45)) ->S : Symbol(S, Decl(reselect.d.ts, 4, 27)) ->R : Symbol(R, Decl(reselect.d.ts, 4, 29)) ->C : Symbol(C, Decl(reselect.d.ts, 4, 32)) ->Selector : Symbol(Selector, Decl(reselect.d.ts, 0, 29)) ->S : Symbol(S, Decl(reselect.d.ts, 4, 27)) ->R : Symbol(R, Decl(reselect.d.ts, 4, 29)) - - resultFunc: C; ->resultFunc : Symbol(resultFunc, Decl(reselect.d.ts, 4, 56)) ->C : Symbol(C, Decl(reselect.d.ts, 4, 32)) - - recomputations: () => number; ->recomputations : Symbol(recomputations, Decl(reselect.d.ts, 5, 16)) - - resetRecomputations: () => number; ->resetRecomputations : Symbol(resetRecomputations, Decl(reselect.d.ts, 6, 31)) - -}; - -export type ParametricSelector = (state: S, props: P, ...args: any[]) => R; ->ParametricSelector : Symbol(ParametricSelector, Decl(reselect.d.ts, 8, 2)) ->S : Symbol(S, Decl(reselect.d.ts, 10, 31)) ->P : Symbol(P, Decl(reselect.d.ts, 10, 33)) ->R : Symbol(R, Decl(reselect.d.ts, 10, 36)) ->state : Symbol(state, Decl(reselect.d.ts, 10, 43)) ->S : Symbol(S, Decl(reselect.d.ts, 10, 31)) ->props : Symbol(props, Decl(reselect.d.ts, 10, 52)) ->P : Symbol(P, Decl(reselect.d.ts, 10, 33)) ->args : Symbol(args, Decl(reselect.d.ts, 10, 62)) ->R : Symbol(R, Decl(reselect.d.ts, 10, 36)) - -export type OutputParametricSelector = ParametricSelector & { ->OutputParametricSelector : Symbol(OutputParametricSelector, Decl(reselect.d.ts, 10, 84)) ->S : Symbol(S, Decl(reselect.d.ts, 12, 37)) ->P : Symbol(P, Decl(reselect.d.ts, 12, 39)) ->R : Symbol(R, Decl(reselect.d.ts, 12, 42)) ->C : Symbol(C, Decl(reselect.d.ts, 12, 45)) ->ParametricSelector : Symbol(ParametricSelector, Decl(reselect.d.ts, 8, 2)) ->S : Symbol(S, Decl(reselect.d.ts, 12, 37)) ->P : Symbol(P, Decl(reselect.d.ts, 12, 39)) ->R : Symbol(R, Decl(reselect.d.ts, 12, 42)) - - resultFunc: C; ->resultFunc : Symbol(resultFunc, Decl(reselect.d.ts, 12, 82)) ->C : Symbol(C, Decl(reselect.d.ts, 12, 45)) - - recomputations: () => number; ->recomputations : Symbol(recomputations, Decl(reselect.d.ts, 13, 16)) - - resetRecomputations: () => number; ->resetRecomputations : Symbol(resetRecomputations, Decl(reselect.d.ts, 14, 31)) - -}; - -/* one selector */ -export function createSelector( ->createSelector : Symbol(createSelector, Decl(reselect.d.ts, 16, 2), Decl(reselect.d.ts, 22, 40), Decl(reselect.d.ts, 26, 53), Decl(reselect.d.ts, 33, 51)) ->S : Symbol(S, Decl(reselect.d.ts, 19, 31)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 19, 33)) ->T : Symbol(T, Decl(reselect.d.ts, 19, 37)) - - selector: Selector, ->selector : Symbol(selector, Decl(reselect.d.ts, 19, 41)) ->Selector : Symbol(Selector, Decl(reselect.d.ts, 0, 29)) ->S : Symbol(S, Decl(reselect.d.ts, 19, 31)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 19, 33)) - - combiner: (res: R1) => T, ->combiner : Symbol(combiner, Decl(reselect.d.ts, 20, 30)) ->res : Symbol(res, Decl(reselect.d.ts, 21, 15)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 19, 33)) ->T : Symbol(T, Decl(reselect.d.ts, 19, 37)) - -): OutputSelector T>; ->OutputSelector : Symbol(OutputSelector, Decl(reselect.d.ts, 2, 45)) ->S : Symbol(S, Decl(reselect.d.ts, 19, 31)) ->T : Symbol(T, Decl(reselect.d.ts, 19, 37)) ->res : Symbol(res, Decl(reselect.d.ts, 22, 25)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 19, 33)) ->T : Symbol(T, Decl(reselect.d.ts, 19, 37)) - -export function createSelector( ->createSelector : Symbol(createSelector, Decl(reselect.d.ts, 16, 2), Decl(reselect.d.ts, 22, 40), Decl(reselect.d.ts, 26, 53), Decl(reselect.d.ts, 33, 51)) ->S : Symbol(S, Decl(reselect.d.ts, 23, 31)) ->P : Symbol(P, Decl(reselect.d.ts, 23, 33)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 23, 36)) ->T : Symbol(T, Decl(reselect.d.ts, 23, 40)) - - selector: ParametricSelector, ->selector : Symbol(selector, Decl(reselect.d.ts, 23, 44)) ->ParametricSelector : Symbol(ParametricSelector, Decl(reselect.d.ts, 8, 2)) ->S : Symbol(S, Decl(reselect.d.ts, 23, 31)) ->P : Symbol(P, Decl(reselect.d.ts, 23, 33)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 23, 36)) - - combiner: (res: R1) => T, ->combiner : Symbol(combiner, Decl(reselect.d.ts, 24, 43)) ->res : Symbol(res, Decl(reselect.d.ts, 25, 15)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 23, 36)) ->T : Symbol(T, Decl(reselect.d.ts, 23, 40)) - -): OutputParametricSelector T>; ->OutputParametricSelector : Symbol(OutputParametricSelector, Decl(reselect.d.ts, 10, 84)) ->S : Symbol(S, Decl(reselect.d.ts, 23, 31)) ->P : Symbol(P, Decl(reselect.d.ts, 23, 33)) ->T : Symbol(T, Decl(reselect.d.ts, 23, 40)) ->res : Symbol(res, Decl(reselect.d.ts, 26, 38)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 23, 36)) ->T : Symbol(T, Decl(reselect.d.ts, 23, 40)) - -/* two selectors */ -export function createSelector( ->createSelector : Symbol(createSelector, Decl(reselect.d.ts, 16, 2), Decl(reselect.d.ts, 22, 40), Decl(reselect.d.ts, 26, 53), Decl(reselect.d.ts, 33, 51)) ->S : Symbol(S, Decl(reselect.d.ts, 29, 31)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 29, 33)) ->R2 : Symbol(R2, Decl(reselect.d.ts, 29, 37)) ->T : Symbol(T, Decl(reselect.d.ts, 29, 41)) - - selector1: Selector, ->selector1 : Symbol(selector1, Decl(reselect.d.ts, 29, 45)) ->Selector : Symbol(Selector, Decl(reselect.d.ts, 0, 29)) ->S : Symbol(S, Decl(reselect.d.ts, 29, 31)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 29, 33)) - - selector2: Selector, ->selector2 : Symbol(selector2, Decl(reselect.d.ts, 30, 31)) ->Selector : Symbol(Selector, Decl(reselect.d.ts, 0, 29)) ->S : Symbol(S, Decl(reselect.d.ts, 29, 31)) ->R2 : Symbol(R2, Decl(reselect.d.ts, 29, 37)) - - combiner: (res1: R1, res2: R2) => T, ->combiner : Symbol(combiner, Decl(reselect.d.ts, 31, 31)) ->res1 : Symbol(res1, Decl(reselect.d.ts, 32, 15)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 29, 33)) ->res2 : Symbol(res2, Decl(reselect.d.ts, 32, 24)) ->R2 : Symbol(R2, Decl(reselect.d.ts, 29, 37)) ->T : Symbol(T, Decl(reselect.d.ts, 29, 41)) - -): OutputSelector T>; ->OutputSelector : Symbol(OutputSelector, Decl(reselect.d.ts, 2, 45)) ->S : Symbol(S, Decl(reselect.d.ts, 29, 31)) ->T : Symbol(T, Decl(reselect.d.ts, 29, 41)) ->res1 : Symbol(res1, Decl(reselect.d.ts, 33, 25)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 29, 33)) ->res2 : Symbol(res2, Decl(reselect.d.ts, 33, 34)) ->R2 : Symbol(R2, Decl(reselect.d.ts, 29, 37)) ->T : Symbol(T, Decl(reselect.d.ts, 29, 41)) - -export function createSelector( ->createSelector : Symbol(createSelector, Decl(reselect.d.ts, 16, 2), Decl(reselect.d.ts, 22, 40), Decl(reselect.d.ts, 26, 53), Decl(reselect.d.ts, 33, 51)) ->S : Symbol(S, Decl(reselect.d.ts, 34, 31)) ->P : Symbol(P, Decl(reselect.d.ts, 34, 33)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 34, 36)) ->R2 : Symbol(R2, Decl(reselect.d.ts, 34, 40)) ->T : Symbol(T, Decl(reselect.d.ts, 34, 44)) - - selector1: ParametricSelector, ->selector1 : Symbol(selector1, Decl(reselect.d.ts, 34, 48)) ->ParametricSelector : Symbol(ParametricSelector, Decl(reselect.d.ts, 8, 2)) ->S : Symbol(S, Decl(reselect.d.ts, 34, 31)) ->P : Symbol(P, Decl(reselect.d.ts, 34, 33)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 34, 36)) - - selector2: ParametricSelector, ->selector2 : Symbol(selector2, Decl(reselect.d.ts, 35, 44)) ->ParametricSelector : Symbol(ParametricSelector, Decl(reselect.d.ts, 8, 2)) ->S : Symbol(S, Decl(reselect.d.ts, 34, 31)) ->P : Symbol(P, Decl(reselect.d.ts, 34, 33)) ->R2 : Symbol(R2, Decl(reselect.d.ts, 34, 40)) - - combiner: (res1: R1, res2: R2) => T, ->combiner : Symbol(combiner, Decl(reselect.d.ts, 36, 44)) ->res1 : Symbol(res1, Decl(reselect.d.ts, 37, 15)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 34, 36)) ->res2 : Symbol(res2, Decl(reselect.d.ts, 37, 24)) ->R2 : Symbol(R2, Decl(reselect.d.ts, 34, 40)) ->T : Symbol(T, Decl(reselect.d.ts, 34, 44)) - -): OutputParametricSelector T>; ->OutputParametricSelector : Symbol(OutputParametricSelector, Decl(reselect.d.ts, 10, 84)) ->S : Symbol(S, Decl(reselect.d.ts, 34, 31)) ->P : Symbol(P, Decl(reselect.d.ts, 34, 33)) ->T : Symbol(T, Decl(reselect.d.ts, 34, 44)) ->res1 : Symbol(res1, Decl(reselect.d.ts, 38, 38)) ->R1 : Symbol(R1, Decl(reselect.d.ts, 34, 36)) ->res2 : Symbol(res2, Decl(reselect.d.ts, 38, 47)) ->R2 : Symbol(R2, Decl(reselect.d.ts, 34, 40)) ->T : Symbol(T, Decl(reselect.d.ts, 34, 44)) - -=== tests/cases/compiler/index.ts === -import { createSelector } from "reselect"; ->createSelector : Symbol(createSelector, Decl(index.ts, 0, 8)) - -/* - * changing the import to - * import * as reselect from 'reselect'; - * and accessing reselect.createSelector fixes the issue -*/ -export interface State { ->State : Symbol(State, Decl(index.ts, 0, 42)) - - a: string; ->a : Symbol(State.a, Decl(index.ts, 6, 24)) - - b: number; ->b : Symbol(State.b, Decl(index.ts, 7, 14)) + a: number; +>a : Symbol(a, Decl(umd.d.ts, 2, 21)) } -export const selector = createSelector( ->selector : Symbol(selector, Decl(index.ts, 10, 12)) ->createSelector : Symbol(createSelector, Decl(index.ts, 0, 8)) ->State : Symbol(State, Decl(index.ts, 0, 42)) ->out : Symbol(out, Decl(index.ts, 10, 63)) - - state => state.a, ->state : Symbol(state, Decl(index.ts, 10, 79)) ->state.a : Symbol(State.a, Decl(index.ts, 6, 24)) ->state : Symbol(state, Decl(index.ts, 10, 79)) ->a : Symbol(State.a, Decl(index.ts, 6, 24)) - state => state.b, ->state : Symbol(state, Decl(index.ts, 11, 21)) ->state.b : Symbol(State.b, Decl(index.ts, 7, 14)) ->state : Symbol(state, Decl(index.ts, 11, 21)) ->b : Symbol(State.b, Decl(index.ts, 7, 14)) +export declare function makeThing(): Thing; +>makeThing : Symbol(makeThing, Decl(umd.d.ts, 4, 1)) +>Thing : Symbol(Thing, Decl(umd.d.ts, 0, 24)) - (a, b) => { ->a : Symbol(a, Decl(index.ts, 13, 5)) ->b : Symbol(b, Decl(index.ts, 13, 7)) - - return { - out: `${a}+${b}` ->out : Symbol(out, Decl(index.ts, 14, 16)) ->a : Symbol(a, Decl(index.ts, 13, 5)) ->b : Symbol(b, Decl(index.ts, 13, 7)) +=== tests/cases/compiler/index.ts === +import { makeThing } from "umd"; +>makeThing : Symbol(makeThing, Decl(index.ts, 0, 8)) - }; - } -); -selector({ a: "string", b: 5 }); ->selector : Symbol(selector, Decl(index.ts, 10, 12)) ->a : Symbol(a, Decl(index.ts, 19, 10)) ->b : Symbol(b, Decl(index.ts, 19, 23)) +export const thing = makeThing(); +>thing : Symbol(thing, Decl(index.ts, 1, 12)) +>makeThing : Symbol(makeThing, Decl(index.ts, 0, 8)) diff --git a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.types b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.types index cf154a619c7eb..2531654f80b92 100644 --- a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.types +++ b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.types @@ -1,268 +1,24 @@ -=== tests/cases/compiler/node_modules/reselect.d.ts === -export as namespace Reselect; ->Reselect : typeof "tests/cases/compiler/node_modules/reselect" +=== tests/cases/compiler/node_modules/umd.d.ts === +export as namespace UMD; +>UMD : typeof "tests/cases/compiler/node_modules/umd" -export type Selector = (state: S) => R; ->Selector : Selector ->S : S ->R : R ->state : S ->S : S ->R : R +export type Thing = { +>Thing : Thing -export type OutputSelector = Selector & { ->OutputSelector : OutputSelector ->S : S ->R : R ->C : C ->Selector : Selector ->S : S ->R : R - - resultFunc: C; ->resultFunc : C ->C : C - - recomputations: () => number; ->recomputations : () => number - - resetRecomputations: () => number; ->resetRecomputations : () => number - -}; - -export type ParametricSelector = (state: S, props: P, ...args: any[]) => R; ->ParametricSelector : ParametricSelector ->S : S ->P : P ->R : R ->state : S ->S : S ->props : P ->P : P ->args : any[] ->R : R - -export type OutputParametricSelector = ParametricSelector & { ->OutputParametricSelector : OutputParametricSelector ->S : S ->P : P ->R : R ->C : C ->ParametricSelector : ParametricSelector ->S : S ->P : P ->R : R - - resultFunc: C; ->resultFunc : C ->C : C - - recomputations: () => number; ->recomputations : () => number - - resetRecomputations: () => number; ->resetRecomputations : () => number - -}; - -/* one selector */ -export function createSelector( ->createSelector : { (selector: Selector, combiner: (res: R1) => T): OutputSelector T>; (selector: ParametricSelector, combiner: (res: R1) => T): OutputParametricSelector T>; (selector1: Selector, selector2: Selector, combiner: (res1: R1, res2: R2) => T): OutputSelector T>; (selector1: ParametricSelector, selector2: ParametricSelector, combiner: (res1: R1, res2: R2) => T): OutputParametricSelector T>; } ->S : S ->R1 : R1 ->T : T - - selector: Selector, ->selector : Selector ->Selector : Selector ->S : S ->R1 : R1 - - combiner: (res: R1) => T, ->combiner : (res: R1) => T ->res : R1 ->R1 : R1 ->T : T - -): OutputSelector T>; ->OutputSelector : OutputSelector ->S : S ->T : T ->res : R1 ->R1 : R1 ->T : T - -export function createSelector( ->createSelector : { (selector: Selector, combiner: (res: R1) => T): OutputSelector T>; (selector: ParametricSelector, combiner: (res: R1) => T): OutputParametricSelector T>; (selector1: Selector, selector2: Selector, combiner: (res1: R1, res2: R2) => T): OutputSelector T>; (selector1: ParametricSelector, selector2: ParametricSelector, combiner: (res1: R1, res2: R2) => T): OutputParametricSelector T>; } ->S : S ->P : P ->R1 : R1 ->T : T - - selector: ParametricSelector, ->selector : ParametricSelector ->ParametricSelector : ParametricSelector ->S : S ->P : P ->R1 : R1 - - combiner: (res: R1) => T, ->combiner : (res: R1) => T ->res : R1 ->R1 : R1 ->T : T - -): OutputParametricSelector T>; ->OutputParametricSelector : OutputParametricSelector ->S : S ->P : P ->T : T ->res : R1 ->R1 : R1 ->T : T - -/* two selectors */ -export function createSelector( ->createSelector : { (selector: Selector, combiner: (res: R1) => T): OutputSelector T>; (selector: ParametricSelector, combiner: (res: R1) => T): OutputParametricSelector T>; (selector1: Selector, selector2: Selector, combiner: (res1: R1, res2: R2) => T): OutputSelector T>; (selector1: ParametricSelector, selector2: ParametricSelector, combiner: (res1: R1, res2: R2) => T): OutputParametricSelector T>; } ->S : S ->R1 : R1 ->R2 : R2 ->T : T - - selector1: Selector, ->selector1 : Selector ->Selector : Selector ->S : S ->R1 : R1 - - selector2: Selector, ->selector2 : Selector ->Selector : Selector ->S : S ->R2 : R2 - - combiner: (res1: R1, res2: R2) => T, ->combiner : (res1: R1, res2: R2) => T ->res1 : R1 ->R1 : R1 ->res2 : R2 ->R2 : R2 ->T : T - -): OutputSelector T>; ->OutputSelector : OutputSelector ->S : S ->T : T ->res1 : R1 ->R1 : R1 ->res2 : R2 ->R2 : R2 ->T : T - -export function createSelector( ->createSelector : { (selector: Selector, combiner: (res: R1) => T): OutputSelector T>; (selector: ParametricSelector, combiner: (res: R1) => T): OutputParametricSelector T>; (selector1: Selector, selector2: Selector, combiner: (res1: R1, res2: R2) => T): OutputSelector T>; (selector1: ParametricSelector, selector2: ParametricSelector, combiner: (res1: R1, res2: R2) => T): OutputParametricSelector T>; } ->S : S ->P : P ->R1 : R1 ->R2 : R2 ->T : T - - selector1: ParametricSelector, ->selector1 : ParametricSelector ->ParametricSelector : ParametricSelector ->S : S ->P : P ->R1 : R1 - - selector2: ParametricSelector, ->selector2 : ParametricSelector ->ParametricSelector : ParametricSelector ->S : S ->P : P ->R2 : R2 - - combiner: (res1: R1, res2: R2) => T, ->combiner : (res1: R1, res2: R2) => T ->res1 : R1 ->R1 : R1 ->res2 : R2 ->R2 : R2 ->T : T - -): OutputParametricSelector T>; ->OutputParametricSelector : OutputParametricSelector ->S : S ->P : P ->T : T ->res1 : R1 ->R1 : R1 ->res2 : R2 ->R2 : R2 ->T : T - -=== tests/cases/compiler/index.ts === -import { createSelector } from "reselect"; ->createSelector : { (selector: (state: S) => R1, combiner: (res: R1) => T): ((state: S) => T) & { resultFunc: (res: R1) => T; recomputations: () => number; resetRecomputations: () => number; }; (selector: (state: S, props: P, ...args: any[]) => R1, combiner: (res: R1) => T): ((state: S, props: P, ...args: any[]) => T) & { resultFunc: (res: R1) => T; recomputations: () => number; resetRecomputations: () => number; }; (selector1: (state: S) => R1, selector2: (state: S) => R2, combiner: (res1: R1, res2: R2) => T): ((state: S) => T) & { resultFunc: (res1: R1, res2: R2) => T; recomputations: () => number; resetRecomputations: () => number; }; (selector1: (state: S, props: P, ...args: any[]) => R1, selector2: (state: S, props: P, ...args: any[]) => R2, combiner: (res1: R1, res2: R2) => T): ((state: S, props: P, ...args: any[]) => T) & { resultFunc: (res1: R1, res2: R2) => T; recomputations: () => number; resetRecomputations: () => number; }; } - -/* - * changing the import to - * import * as reselect from 'reselect'; - * and accessing reselect.createSelector fixes the issue -*/ -export interface State { ->State : State - - a: string; ->a : string - - b: number; ->b : number + a: number; +>a : number } -export const selector = createSelector( ->selector : ((state: State) => { out: string; }) & { resultFunc: (res1: string, res2: number) => { out: string; }; recomputations: () => number; resetRecomputations: () => number; } ->createSelector( state => state.a, state => state.b, (a, b) => { return { out: `${a}+${b}` }; }) : ((state: State) => { out: string; }) & { resultFunc: (res1: string, res2: number) => { out: string; }; recomputations: () => number; resetRecomputations: () => number; } ->createSelector : { (selector: (state: S) => R1, combiner: (res: R1) => T): ((state: S) => T) & { resultFunc: (res: R1) => T; recomputations: () => number; resetRecomputations: () => number; }; (selector: (state: S, props: P, ...args: any[]) => R1, combiner: (res: R1) => T): ((state: S, props: P, ...args: any[]) => T) & { resultFunc: (res: R1) => T; recomputations: () => number; resetRecomputations: () => number; }; (selector1: (state: S) => R1, selector2: (state: S) => R2, combiner: (res1: R1, res2: R2) => T): ((state: S) => T) & { resultFunc: (res1: R1, res2: R2) => T; recomputations: () => number; resetRecomputations: () => number; }; (selector1: (state: S, props: P, ...args: any[]) => R1, selector2: (state: S, props: P, ...args: any[]) => R2, combiner: (res1: R1, res2: R2) => T): ((state: S, props: P, ...args: any[]) => T) & { resultFunc: (res1: R1, res2: R2) => T; recomputations: () => number; resetRecomputations: () => number; }; } ->State : State ->out : string - state => state.a, ->state => state.a : (state: State) => string ->state : State ->state.a : string ->state : State ->a : string +export declare function makeThing(): Thing; +>makeThing : () => Thing +>Thing : Thing - state => state.b, ->state => state.b : (state: State) => number ->state : State ->state.b : number ->state : State ->b : number - - (a, b) => { ->(a, b) => { return { out: `${a}+${b}` }; } : (a: string, b: number) => { out: string; } ->a : string ->b : number - - return { ->{ out: `${a}+${b}` } : { out: string; } - - out: `${a}+${b}` ->out : string ->`${a}+${b}` : string ->a : string ->b : number +=== tests/cases/compiler/index.ts === +import { makeThing } from "umd"; +>makeThing : () => { a: number; } - }; - } -); -selector({ a: "string", b: 5 }); ->selector({ a: "string", b: 5 }) : { out: string; } ->selector : ((state: State) => { out: string; }) & { resultFunc: (res1: string, res2: number) => { out: string; }; recomputations: () => number; resetRecomputations: () => number; } ->{ a: "string", b: 5 } : { a: string; b: number; } ->a : string ->"string" : "string" ->b : number ->5 : 5 +export const thing = makeThing(); +>thing : { a: number; } +>makeThing() : { a: number; } +>makeThing : () => { a: number; } diff --git a/tests/cases/compiler/importShouldNotBeElidedInDeclarationEmit.ts b/tests/cases/compiler/importShouldNotBeElidedInDeclarationEmit.ts index 0feb15a4b56ce..a6d77a5156709 100644 --- a/tests/cases/compiler/importShouldNotBeElidedInDeclarationEmit.ts +++ b/tests/cases/compiler/importShouldNotBeElidedInDeclarationEmit.ts @@ -1,63 +1,12 @@ // @declaration: true -// @filename: node_modules/reselect.d.ts -export as namespace Reselect; +// @filename: node_modules/umd.d.ts +export as namespace UMD; -export type Selector = (state: S) => R; - -export type OutputSelector = Selector & { - resultFunc: C; - recomputations: () => number; - resetRecomputations: () => number; -}; - -export type ParametricSelector = (state: S, props: P, ...args: any[]) => R; - -export type OutputParametricSelector = ParametricSelector & { - resultFunc: C; - recomputations: () => number; - resetRecomputations: () => number; -}; - -/* one selector */ -export function createSelector( - selector: Selector, - combiner: (res: R1) => T, -): OutputSelector T>; -export function createSelector( - selector: ParametricSelector, - combiner: (res: R1) => T, -): OutputParametricSelector T>; - -/* two selectors */ -export function createSelector( - selector1: Selector, - selector2: Selector, - combiner: (res1: R1, res2: R2) => T, -): OutputSelector T>; -export function createSelector( - selector1: ParametricSelector, - selector2: ParametricSelector, - combiner: (res1: R1, res2: R2) => T, -): OutputParametricSelector T>; +export type Thing = { + a: number; +} +export declare function makeThing(): Thing; // @filename: index.ts -import { createSelector } from "reselect"; -/* - * changing the import to - * import * as reselect from 'reselect'; - * and accessing reselect.createSelector fixes the issue -*/ -export interface State { - a: string; - b: number; -} -export const selector = createSelector( - state => state.a, - state => state.b, - (a, b) => { - return { - out: `${a}+${b}` - }; - } -); -selector({ a: "string", b: 5 }); \ No newline at end of file +import { makeThing } from "umd"; +export const thing = makeThing();