From 7a9c11c72beec980b19bc9962ecbdde3208e37b0 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Mon, 5 Dec 2016 16:27:59 -0800 Subject: [PATCH 01/24] Test:destructuring array initialisers refer to previous elements --- .../destructuringArrayBindingPatternAndAssignment3.ts | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts diff --git a/tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts b/tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts new file mode 100644 index 0000000000000..f053745689171 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts @@ -0,0 +1,4 @@ +const [a, b = a] = [1]; // ok +const [a, b = a, c = c] = [1]; // error for c +const [a, b = a, c = d, d = a] = [1]; // error for c + From 92f2721b4619bfe956c64acace0130dc4ffa0bf1 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Tue, 6 Dec 2016 11:48:14 -0800 Subject: [PATCH 02/24] Binding initialisers can refer to previous elements --- src/compiler/checker.ts | 31 +++++++++++++++++++++++++++---- 1 file changed, 27 insertions(+), 4 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 903c8cfda1c20..7ea84d093ec00 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -638,11 +638,24 @@ namespace ts { if (declaration.pos <= usage.pos) { // declaration is before usage - // still might be illegal if usage is in the initializer of the variable declaration - return declaration.kind !== SyntaxKind.VariableDeclaration || - !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage); + if (declaration.kind === SyntaxKind.BindingElement) { + // still might be illegal if declaration and usage are both binding elements (eg var [a = b, b = b] = [1, 2]) + const errorBindingElement = getAncestor(usage, SyntaxKind.BindingElement) as BindingElement; + if (errorBindingElement) { + return getAncestorBindingPattern(errorBindingElement) !== getAncestorBindingPattern(declaration) || + declaration.pos < errorBindingElement.pos; + } + // or it might be illegal if usage happens before parent variable is declared (eg var [a] = a) + return isBlockScopedNameDeclaredBeforeUse(getAncestor(declaration, SyntaxKind.VariableDeclaration) as Declaration, usage); + } + else if (declaration.kind === SyntaxKind.VariableDeclaration) { + // still might be illegal if usage is in the initializer of the variable declaration (eg var a = a) + return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration as VariableDeclaration, usage); + } + return true; } + // declaration is after usage // can be legal if usage is deferred (i.e. inside function or in initializer of instance property) const container = getEnclosingBlockScopeContainer(declaration); @@ -699,6 +712,16 @@ namespace ts { } return false; } + + function getAncestorBindingPattern(node: Node): BindingPattern { + while (node) { + if (isBindingPattern(node)) { + return node; + } + node = node.parent; + } + return undefined; + } } // Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and @@ -1065,7 +1088,7 @@ namespace ts { Debug.assert(declaration !== undefined, "Block-scoped variable declaration is undefined"); - if (!isInAmbientContext(declaration) && !isBlockScopedNameDeclaredBeforeUse(getAncestor(declaration, SyntaxKind.VariableDeclaration), errorLocation)) { + if (!isInAmbientContext(declaration) && !isBlockScopedNameDeclaredBeforeUse(declaration, errorLocation)) { error(errorLocation, Diagnostics.Block_scoped_variable_0_used_before_its_declaration, declarationNameToString(declaration.name)); } } From 72a1e85cd7f1b189b509a723ed8473ae265573ca Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Tue, 6 Dec 2016 13:04:45 -0800 Subject: [PATCH 03/24] Check binding initialisers in parameters as well --- src/compiler/checker.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 7ea84d093ec00..61ccbff9bb003 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -17041,7 +17041,8 @@ namespace ts { // so we need to do a bit of extra work to check if reference is legal const enclosingContainer = getEnclosingBlockScopeContainer(symbol.valueDeclaration); if (enclosingContainer === func) { - if (symbol.valueDeclaration.kind === SyntaxKind.Parameter) { + if (symbol.valueDeclaration.kind === SyntaxKind.Parameter || + symbol.valueDeclaration.kind === SyntaxKind.BindingElement) { // it is ok to reference parameter in initializer if either // - parameter is located strictly on the left of current parameter declaration if (symbol.valueDeclaration.pos < node.pos) { From 4efa61cf80aa66512a892f8db40bfa1aee1c0fe7 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Tue, 6 Dec 2016 13:05:52 -0800 Subject: [PATCH 04/24] More tests for binding elements referencing previous elements --- .../destructuringArrayBindingPatternAndAssignment3.ts | 10 ++++++++-- .../destructuringObjectBindingPatternAndAssignment4.ts | 8 ++++++++ 2 files changed, 16 insertions(+), 2 deletions(-) create mode 100644 tests/cases/conformance/es6/destructuring/destructuringObjectBindingPatternAndAssignment4.ts diff --git a/tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts b/tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts index f053745689171..243a297ed4381 100644 --- a/tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts +++ b/tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts @@ -1,4 +1,10 @@ const [a, b = a] = [1]; // ok -const [a, b = a, c = c] = [1]; // error for c -const [a, b = a, c = d, d = a] = [1]; // error for c +const [c, d = c, e = e] = [1]; // error for e = e +const [f, g = f, h = i, i = f] = [1]; // error for h = i +(function ([a, b = a]) { // ok +})([1]); +(function ([c, d = c, e = e]) { // error for e = e +})([1]); +(function ([f, g = f, h = i, i = f]) { // error for h = i +})([1]) diff --git a/tests/cases/conformance/es6/destructuring/destructuringObjectBindingPatternAndAssignment4.ts b/tests/cases/conformance/es6/destructuring/destructuringObjectBindingPatternAndAssignment4.ts new file mode 100644 index 0000000000000..d138c14db7add --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/destructuringObjectBindingPatternAndAssignment4.ts @@ -0,0 +1,8 @@ +const { + a = 1, + b = 2, + c = b, // ok + d = a, // ok + e = f, // error + f = f // error +} = { } as any; From 77b6482936c44062d26eeb2099079049d278a1ef Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Tue, 6 Dec 2016 13:06:26 -0800 Subject: [PATCH 05/24] Add baselines for new tests --- ...rayBindingPatternAndAssignment3.errors.txt | 26 +++++++++++++++++++ ...turingArrayBindingPatternAndAssignment3.js | 26 +++++++++++++++++++ ...ectBindingPatternAndAssignment4.errors.txt | 18 +++++++++++++ ...uringObjectBindingPatternAndAssignment4.js | 21 +++++++++++++++ 4 files changed, 91 insertions(+) create mode 100644 tests/baselines/reference/destructuringArrayBindingPatternAndAssignment3.errors.txt create mode 100644 tests/baselines/reference/destructuringArrayBindingPatternAndAssignment3.js create mode 100644 tests/baselines/reference/destructuringObjectBindingPatternAndAssignment4.errors.txt create mode 100644 tests/baselines/reference/destructuringObjectBindingPatternAndAssignment4.js diff --git a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment3.errors.txt b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment3.errors.txt new file mode 100644 index 0000000000000..a68affcf73de8 --- /dev/null +++ b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment3.errors.txt @@ -0,0 +1,26 @@ +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts(2,22): error TS2448: Block-scoped variable 'e' used before its declaration. +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts(3,22): error TS2448: Block-scoped variable 'i' used before its declaration. +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts(7,27): error TS2372: Parameter 'e' cannot be referenced in its initializer. +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts(9,27): error TS2373: Initializer of parameter 'h' cannot reference identifier 'i' declared after it. + + +==== tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment3.ts (4 errors) ==== + const [a, b = a] = [1]; // ok + const [c, d = c, e = e] = [1]; // error for e = e + ~ +!!! error TS2448: Block-scoped variable 'e' used before its declaration. + const [f, g = f, h = i, i = f] = [1]; // error for h = i + ~ +!!! error TS2448: Block-scoped variable 'i' used before its declaration. + + (function ([a, b = a]) { // ok + })([1]); + (function ([c, d = c, e = e]) { // error for e = e + ~ +!!! error TS2372: Parameter 'e' cannot be referenced in its initializer. + })([1]); + (function ([f, g = f, h = i, i = f]) { // error for h = i + ~ +!!! error TS2373: Initializer of parameter 'h' cannot reference identifier 'i' declared after it. + })([1]) + \ No newline at end of file diff --git a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment3.js b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment3.js new file mode 100644 index 0000000000000..7073061dec6fb --- /dev/null +++ b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment3.js @@ -0,0 +1,26 @@ +//// [destructuringArrayBindingPatternAndAssignment3.ts] +const [a, b = a] = [1]; // ok +const [c, d = c, e = e] = [1]; // error for e = e +const [f, g = f, h = i, i = f] = [1]; // error for h = i + +(function ([a, b = a]) { // ok +})([1]); +(function ([c, d = c, e = e]) { // error for e = e +})([1]); +(function ([f, g = f, h = i, i = f]) { // error for h = i +})([1]) + + +//// [destructuringArrayBindingPatternAndAssignment3.js] +var _a = [1], a = _a[0], _b = _a[1], b = _b === void 0 ? a : _b; // ok +var _c = [1], c = _c[0], _d = _c[1], d = _d === void 0 ? c : _d, _e = _c[2], e = _e === void 0 ? e : _e; // error for e = e +var _f = [1], f = _f[0], _g = _f[1], g = _g === void 0 ? f : _g, _h = _f[2], h = _h === void 0 ? i : _h, _j = _f[3], i = _j === void 0 ? f : _j; // error for h = i +(function (_a) { + var a = _a[0], _b = _a[1], b = _b === void 0 ? a : _b; +})([1]); +(function (_a) { + var c = _a[0], _b = _a[1], d = _b === void 0 ? c : _b, _c = _a[2], e = _c === void 0 ? e : _c; +})([1]); +(function (_a) { + var f = _a[0], _b = _a[1], g = _b === void 0 ? f : _b, _c = _a[2], h = _c === void 0 ? i : _c, _d = _a[3], i = _d === void 0 ? f : _d; +})([1]); diff --git a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment4.errors.txt b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment4.errors.txt new file mode 100644 index 0000000000000..6a3f0f2b4572b --- /dev/null +++ b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment4.errors.txt @@ -0,0 +1,18 @@ +tests/cases/conformance/es6/destructuring/destructuringObjectBindingPatternAndAssignment4.ts(6,9): error TS2448: Block-scoped variable 'f' used before its declaration. +tests/cases/conformance/es6/destructuring/destructuringObjectBindingPatternAndAssignment4.ts(7,9): error TS2448: Block-scoped variable 'f' used before its declaration. + + +==== tests/cases/conformance/es6/destructuring/destructuringObjectBindingPatternAndAssignment4.ts (2 errors) ==== + const { + a = 1, + b = 2, + c = b, // ok + d = a, // ok + e = f, // error + ~ +!!! error TS2448: Block-scoped variable 'f' used before its declaration. + f = f // error + ~ +!!! error TS2448: Block-scoped variable 'f' used before its declaration. + } = { } as any; + \ No newline at end of file diff --git a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment4.js b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment4.js new file mode 100644 index 0000000000000..c34cbb62c1cab --- /dev/null +++ b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment4.js @@ -0,0 +1,21 @@ +//// [destructuringObjectBindingPatternAndAssignment4.ts] +const { + a = 1, + b = 2, + c = b, // ok + d = a, // ok + e = f, // error + f = f // error +} = { } as any; + + +//// [destructuringObjectBindingPatternAndAssignment4.js] +var _a = {}, _b = _a.a, a = _b === void 0 ? 1 : _b, _c = _a.b, b = _c === void 0 ? 2 : _c, _d = _a.c, c = _d === void 0 ? b : _d, // ok +_e = _a.d, // ok +d = _e === void 0 ? a : _e, // ok +_f = _a.e, // ok +e = _f === void 0 ? f : _f, // error +_g = _a.f // error +, // error +f = _g === void 0 ? f : _g // error +; From 8ae9c7de21d3ec9a5e41c0e154947ca437fd98b8 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Fri, 16 Dec 2016 09:49:29 -0800 Subject: [PATCH 06/24] JSDoc functions are now in scope for instantiation Previously, `isSymbolInScopeOfMappedTypeParameter` did not understand JSDoc, so it would cause generic function declarations in JSDoc not be instantiated. --- src/compiler/checker.ts | 12 ++++++++++-- tests/cases/fourslash/jsDocGenerics2.ts | 19 +++++++++++++++++++ 2 files changed, 29 insertions(+), 2 deletions(-) create mode 100644 tests/cases/fourslash/jsDocGenerics2.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 26164a528f34b..5bcb5f90d55a8 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6634,7 +6634,7 @@ namespace ts { // Starting with the parent of the symbol's declaration, check if the mapper maps any of // the type parameters introduced by enclosing declarations. We just pick the first // declaration since multiple declarations will all have the same parent anyway. - let node = symbol.declarations[0].parent; + let node: Node = symbol.declarations[0]; while (node) { switch (node.kind) { case SyntaxKind.FunctionType: @@ -6654,7 +6654,7 @@ namespace ts { case SyntaxKind.ClassExpression: case SyntaxKind.InterfaceDeclaration: case SyntaxKind.TypeAliasDeclaration: - const declaration = node; + const declaration = node as DeclarationWithTypeParameters; if (declaration.typeParameters) { for (const d of declaration.typeParameters) { if (contains(mappedTypes, getDeclaredTypeOfTypeParameter(getSymbolOfNode(d)))) { @@ -6669,6 +6669,14 @@ namespace ts { } } break; + case SyntaxKind.JSDocFunctionType: + const func = node as JSDocFunctionType; + for (const p of func.parameters) { + if (contains(mappedTypes, getTypeOfNode(p))) { + return true; + } + } + break; case SyntaxKind.ModuleDeclaration: case SyntaxKind.SourceFile: return false; diff --git a/tests/cases/fourslash/jsDocGenerics2.ts b/tests/cases/fourslash/jsDocGenerics2.ts new file mode 100644 index 0000000000000..23deb1a650245 --- /dev/null +++ b/tests/cases/fourslash/jsDocGenerics2.ts @@ -0,0 +1,19 @@ +/// +// @allowNonTsExtensions: true +// @Filename: Foo.js + +/////** +//// * @param {T[]} arr +//// * @param {(function(T):T)} valuator +//// * @template T +//// */ +////function SortFilter(arr,valuator) +////{ +//// return arr; +////} +////var a/*1*/ = SortFilter([0, 1, 2], q/*2*/ => q); +////var b/*3*/ = SortFilter([0, 1, 2], undefined); + +verify.quickInfoAt('1', "var a: number[]"); +verify.quickInfoAt('2', '(parameter) q: number'); +verify.quickInfoAt('3', "var b: number[]"); From 59403796c70ec51d1f40c398befa50768ca7b289 Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Tue, 29 Nov 2016 12:42:17 -0800 Subject: [PATCH 07/24] Add serialization of typenode for null/undefined/never as part of metadata type Fixes #12684 and #11933 --- src/compiler/transformers/ts.ts | 41 ++++++---- src/compiler/utilities.ts | 4 + .../reference/metadataOfUnionWithNull.js | 78 +++++++++++++++++++ .../reference/metadataOfUnionWithNull.symbols | 56 +++++++++++++ .../reference/metadataOfUnionWithNull.types | 60 ++++++++++++++ .../cases/compiler/metadataOfUnionWithNull.ts | 29 +++++++ 6 files changed, 253 insertions(+), 15 deletions(-) create mode 100644 tests/baselines/reference/metadataOfUnionWithNull.js create mode 100644 tests/baselines/reference/metadataOfUnionWithNull.symbols create mode 100644 tests/baselines/reference/metadataOfUnionWithNull.types create mode 100644 tests/cases/compiler/metadataOfUnionWithNull.ts diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 877131b369c87..366c94aa629c6 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -1662,6 +1662,8 @@ namespace ts { switch (node.kind) { case SyntaxKind.VoidKeyword: + case SyntaxKind.UndefinedKeyword: + case SyntaxKind.NullKeyword: return createVoidZero(); case SyntaxKind.ParenthesizedType: @@ -1715,27 +1717,35 @@ namespace ts { case SyntaxKind.UnionType: { const unionOrIntersection = node; - let serializedUnion: Identifier; + let serializedUnion: Identifier | VoidExpression; for (const typeNode of unionOrIntersection.types) { - const serializedIndividual = serializeTypeNode(typeNode) as Identifier; - // Non identifier - if (serializedIndividual.kind !== SyntaxKind.Identifier) { - serializedUnion = undefined; - break; - } + const serializedIndividual = serializeTypeNode(typeNode); - // One of the individual is global object, return immediately - if (serializedIndividual.text === "Object") { - return serializedIndividual; - } + if (isIdentifier(serializedIndividual)) { + // One of the individual is global object, return immediately + if (serializedIndividual.text === "Object") { + return serializedIndividual; + } + + // Different types + if (serializedUnion && isIdentifier(serializedUnion) && serializedUnion.text !== serializedIndividual.text) { + serializedUnion = undefined; + break; + } - // Different types - if (serializedUnion && serializedUnion.text !== serializedIndividual.text) { + serializedUnion = serializedIndividual; + } + else if (isVoidExpression(serializedIndividual)) { + // If we dont have any other type already set, set the initial type + if (!serializedUnion) { + serializedUnion = serializedIndividual; + } + } + else { + // Non identifier and undefined/null serializedUnion = undefined; break; } - - serializedUnion = serializedIndividual; } // If we were able to find common type @@ -1751,6 +1761,7 @@ namespace ts { case SyntaxKind.TypeLiteral: case SyntaxKind.AnyKeyword: case SyntaxKind.ThisType: + case SyntaxKind.NeverKeyword: break; default: diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 6f491f6708fee..0914b0d0c246c 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -3581,6 +3581,10 @@ namespace ts { return node.kind === SyntaxKind.Identifier; } + export function isVoidExpression(node: Node): node is VoidExpression { + return node.kind === SyntaxKind.VoidExpression; + } + export function isGeneratedIdentifier(node: Node): node is GeneratedIdentifier { // Using `>` here catches both `GeneratedIdentifierKind.None` and `undefined`. return isIdentifier(node) && node.autoGenerateKind > GeneratedIdentifierKind.None; diff --git a/tests/baselines/reference/metadataOfUnionWithNull.js b/tests/baselines/reference/metadataOfUnionWithNull.js new file mode 100644 index 0000000000000..7b4b734b83417 --- /dev/null +++ b/tests/baselines/reference/metadataOfUnionWithNull.js @@ -0,0 +1,78 @@ +//// [metadataOfUnionWithNull.ts] +function PropDeco(target: Object, propKey: string | symbol) { } + +class A { +} + +class B { + @PropDeco + x: "foo" | null; + + @PropDeco + y: true | never; + + @PropDeco + z: "foo" | undefined; + + @PropDeco + a: null; + + @PropDeco + b: never; + + @PropDeco + c: undefined; + + @PropDeco + d: undefined | null; +} + +//// [metadataOfUnionWithNull.js] +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +function PropDeco(target, propKey) { } +var A = (function () { + function A() { + } + return A; +}()); +var B = (function () { + function B() { + } + return B; +}()); +__decorate([ + PropDeco, + __metadata("design:type", String) +], B.prototype, "x"); +__decorate([ + PropDeco, + __metadata("design:type", Object) +], B.prototype, "y"); +__decorate([ + PropDeco, + __metadata("design:type", String) +], B.prototype, "z"); +__decorate([ + PropDeco, + __metadata("design:type", void 0) +], B.prototype, "a"); +__decorate([ + PropDeco, + __metadata("design:type", Object) +], B.prototype, "b"); +__decorate([ + PropDeco, + __metadata("design:type", void 0) +], B.prototype, "c"); +__decorate([ + PropDeco, + __metadata("design:type", void 0) +], B.prototype, "d"); diff --git a/tests/baselines/reference/metadataOfUnionWithNull.symbols b/tests/baselines/reference/metadataOfUnionWithNull.symbols new file mode 100644 index 0000000000000..13533a26699a2 --- /dev/null +++ b/tests/baselines/reference/metadataOfUnionWithNull.symbols @@ -0,0 +1,56 @@ +=== tests/cases/compiler/metadataOfUnionWithNull.ts === +function PropDeco(target: Object, propKey: string | symbol) { } +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) +>target : Symbol(target, Decl(metadataOfUnionWithNull.ts, 0, 18)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>propKey : Symbol(propKey, Decl(metadataOfUnionWithNull.ts, 0, 33)) + +class A { +>A : Symbol(A, Decl(metadataOfUnionWithNull.ts, 0, 63)) +} + +class B { +>B : Symbol(B, Decl(metadataOfUnionWithNull.ts, 3, 1)) + + @PropDeco +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) + + x: "foo" | null; +>x : Symbol(B.x, Decl(metadataOfUnionWithNull.ts, 5, 9)) + + @PropDeco +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) + + y: true | never; +>y : Symbol(B.y, Decl(metadataOfUnionWithNull.ts, 7, 20)) + + @PropDeco +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) + + z: "foo" | undefined; +>z : Symbol(B.z, Decl(metadataOfUnionWithNull.ts, 10, 20)) + + @PropDeco +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) + + a: null; +>a : Symbol(B.a, Decl(metadataOfUnionWithNull.ts, 13, 25)) + + @PropDeco +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) + + b: never; +>b : Symbol(B.b, Decl(metadataOfUnionWithNull.ts, 16, 12)) + + @PropDeco +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) + + c: undefined; +>c : Symbol(B.c, Decl(metadataOfUnionWithNull.ts, 19, 13)) + + @PropDeco +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) + + d: undefined | null; +>d : Symbol(B.d, Decl(metadataOfUnionWithNull.ts, 22, 17)) +} diff --git a/tests/baselines/reference/metadataOfUnionWithNull.types b/tests/baselines/reference/metadataOfUnionWithNull.types new file mode 100644 index 0000000000000..e6037e16cb3b0 --- /dev/null +++ b/tests/baselines/reference/metadataOfUnionWithNull.types @@ -0,0 +1,60 @@ +=== tests/cases/compiler/metadataOfUnionWithNull.ts === +function PropDeco(target: Object, propKey: string | symbol) { } +>PropDeco : (target: Object, propKey: string | symbol) => void +>target : Object +>Object : Object +>propKey : string | symbol + +class A { +>A : A +} + +class B { +>B : B + + @PropDeco +>PropDeco : (target: Object, propKey: string | symbol) => void + + x: "foo" | null; +>x : "foo" +>null : null + + @PropDeco +>PropDeco : (target: Object, propKey: string | symbol) => void + + y: true | never; +>y : true +>true : true + + @PropDeco +>PropDeco : (target: Object, propKey: string | symbol) => void + + z: "foo" | undefined; +>z : "foo" + + @PropDeco +>PropDeco : (target: Object, propKey: string | symbol) => void + + a: null; +>a : null +>null : null + + @PropDeco +>PropDeco : (target: Object, propKey: string | symbol) => void + + b: never; +>b : never + + @PropDeco +>PropDeco : (target: Object, propKey: string | symbol) => void + + c: undefined; +>c : undefined + + @PropDeco +>PropDeco : (target: Object, propKey: string | symbol) => void + + d: undefined | null; +>d : null +>null : null +} diff --git a/tests/cases/compiler/metadataOfUnionWithNull.ts b/tests/cases/compiler/metadataOfUnionWithNull.ts new file mode 100644 index 0000000000000..475024229fced --- /dev/null +++ b/tests/cases/compiler/metadataOfUnionWithNull.ts @@ -0,0 +1,29 @@ +// @experimentalDecorators: true +// @emitDecoratorMetadata: true +function PropDeco(target: Object, propKey: string | symbol) { } + +class A { +} + +class B { + @PropDeco + x: "foo" | null; + + @PropDeco + y: true | never; + + @PropDeco + z: "foo" | undefined; + + @PropDeco + a: null; + + @PropDeco + b: never; + + @PropDeco + c: undefined; + + @PropDeco + d: undefined | null; +} \ No newline at end of file From 73a829279ab9534802763bbda02aaf6816e08eaa Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Tue, 29 Nov 2016 12:42:17 -0800 Subject: [PATCH 08/24] Support union of non identifier serialized type node with null/undefined/never --- src/compiler/transformers/ts.ts | 91 ++++++++++--------- .../reference/metadataOfUnionWithNull.js | 39 +++++++- .../reference/metadataOfUnionWithNull.symbols | 33 +++++++ .../reference/metadataOfUnionWithNull.types | 37 ++++++++ .../cases/compiler/metadataOfUnionWithNull.ts | 15 +++ 5 files changed, 168 insertions(+), 47 deletions(-) diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 366c94aa629c6..ecd2e2dfcfd9d 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -1637,6 +1637,8 @@ namespace ts { return createVoidZero(); } + type SerializedTypeNode = SerializedEntityNameAsExpression | VoidExpression | ConditionalExpression; + /** * Serializes a type node for use with decorator type metadata. * @@ -1655,7 +1657,7 @@ namespace ts { * * @param node The type node to serialize. */ - function serializeTypeNode(node: TypeNode): Expression { + function serializeTypeNode(node: TypeNode): SerializedTypeNode { if (node === undefined) { return createIdentifier("Object"); } @@ -1664,6 +1666,7 @@ namespace ts { case SyntaxKind.VoidKeyword: case SyntaxKind.UndefinedKeyword: case SyntaxKind.NullKeyword: + case SyntaxKind.NeverKeyword: return createVoidZero(); case SyntaxKind.ParenthesizedType: @@ -1715,45 +1718,8 @@ namespace ts { case SyntaxKind.IntersectionType: case SyntaxKind.UnionType: - { - const unionOrIntersection = node; - let serializedUnion: Identifier | VoidExpression; - for (const typeNode of unionOrIntersection.types) { - const serializedIndividual = serializeTypeNode(typeNode); - - if (isIdentifier(serializedIndividual)) { - // One of the individual is global object, return immediately - if (serializedIndividual.text === "Object") { - return serializedIndividual; - } - - // Different types - if (serializedUnion && isIdentifier(serializedUnion) && serializedUnion.text !== serializedIndividual.text) { - serializedUnion = undefined; - break; - } - - serializedUnion = serializedIndividual; - } - else if (isVoidExpression(serializedIndividual)) { - // If we dont have any other type already set, set the initial type - if (!serializedUnion) { - serializedUnion = serializedIndividual; - } - } - else { - // Non identifier and undefined/null - serializedUnion = undefined; - break; - } - } + return serializeUnionOrIntersectionType(node); - // If we were able to find common type - if (serializedUnion) { - return serializedUnion; - } - } - // Fallthrough case SyntaxKind.TypeQuery: case SyntaxKind.TypeOperator: case SyntaxKind.IndexedAccessType: @@ -1761,7 +1727,6 @@ namespace ts { case SyntaxKind.TypeLiteral: case SyntaxKind.AnyKeyword: case SyntaxKind.ThisType: - case SyntaxKind.NeverKeyword: break; default: @@ -1772,13 +1737,48 @@ namespace ts { return createIdentifier("Object"); } + function serializeUnionOrIntersectionType(node: UnionOrIntersectionTypeNode): SerializedTypeNode { + let serializedUnion: SerializedTypeNode; + for (const typeNode of node.types) { + const serializedIndividual = serializeTypeNode(typeNode); + + if (isVoidExpression(serializedIndividual)) { + // If we dont have any other type already set, set the initial type + if (!serializedUnion) { + serializedUnion = serializedIndividual; + } + } + else if (isIdentifier(serializedIndividual) && serializedIndividual.text === "Object") { + // One of the individual is global object, return immediately + return serializedIndividual; + } + // If there exists union that is not void 0 expression, check if the the common type is identifier. + // anything more complex and we will just default to Object + else if (serializedUnion && !isVoidExpression(serializedUnion)) { + // Different types + if (!isIdentifier(serializedUnion) || + !isIdentifier(serializedIndividual) || + serializedUnion.text !== serializedIndividual.text) { + return createIdentifier("Object"); + } + } + else { + // Initialize the union type + serializedUnion = serializedIndividual; + } + } + + // If we were able to find common type, use it + return serializedUnion; + } + /** * Serializes a TypeReferenceNode to an appropriate JS constructor value for use with * decorator type metadata. * * @param node The type reference node. */ - function serializeTypeReferenceNode(node: TypeReferenceNode) { + function serializeTypeReferenceNode(node: TypeReferenceNode): SerializedTypeNode { switch (resolver.getTypeReferenceSerializationKind(node.typeName, currentScope)) { case TypeReferenceSerializationKind.Unknown: const serialized = serializeEntityNameAsExpression(node.typeName, /*useFallback*/ true); @@ -1826,6 +1826,7 @@ namespace ts { } } + type SerializedEntityNameAsExpression = Identifier | BinaryExpression | PropertyAccessExpression; /** * Serializes an entity name as an expression for decorator type metadata. * @@ -1833,7 +1834,7 @@ namespace ts { * @param useFallback A value indicating whether to use logical operators to test for the * entity name at runtime. */ - function serializeEntityNameAsExpression(node: EntityName, useFallback: boolean): Expression { + function serializeEntityNameAsExpression(node: EntityName, useFallback: boolean): SerializedEntityNameAsExpression { switch (node.kind) { case SyntaxKind.Identifier: // Create a clone of the name with a new parent, and treat it as if it were @@ -1866,8 +1867,8 @@ namespace ts { * @param useFallback A value indicating whether to use logical operators to test for the * qualified name at runtime. */ - function serializeQualifiedNameAsExpression(node: QualifiedName, useFallback: boolean): Expression { - let left: Expression; + function serializeQualifiedNameAsExpression(node: QualifiedName, useFallback: boolean): PropertyAccessExpression { + let left: SerializedEntityNameAsExpression; if (node.left.kind === SyntaxKind.Identifier) { left = serializeEntityNameAsExpression(node.left, useFallback); } @@ -1892,7 +1893,7 @@ namespace ts { * Gets an expression that points to the global "Symbol" constructor at runtime if it is * available. */ - function getGlobalSymbolNameWithFallback(): Expression { + function getGlobalSymbolNameWithFallback(): ConditionalExpression { return createConditional( createTypeCheck(createIdentifier("Symbol"), "function"), createIdentifier("Symbol"), diff --git a/tests/baselines/reference/metadataOfUnionWithNull.js b/tests/baselines/reference/metadataOfUnionWithNull.js index 7b4b734b83417..cc594ae326dc3 100644 --- a/tests/baselines/reference/metadataOfUnionWithNull.js +++ b/tests/baselines/reference/metadataOfUnionWithNull.js @@ -25,6 +25,21 @@ class B { @PropDeco d: undefined | null; + + @PropDeco + e: symbol | null; + + @PropDeco + f: symbol | A; + + @PropDeco + g: A | null; + + @PropDeco + h: null | B; + + @PropDeco + j: null | symbol; } //// [metadataOfUnionWithNull.js] @@ -54,7 +69,7 @@ __decorate([ ], B.prototype, "x"); __decorate([ PropDeco, - __metadata("design:type", Object) + __metadata("design:type", Boolean) ], B.prototype, "y"); __decorate([ PropDeco, @@ -66,7 +81,7 @@ __decorate([ ], B.prototype, "a"); __decorate([ PropDeco, - __metadata("design:type", Object) + __metadata("design:type", void 0) ], B.prototype, "b"); __decorate([ PropDeco, @@ -76,3 +91,23 @@ __decorate([ PropDeco, __metadata("design:type", void 0) ], B.prototype, "d"); +__decorate([ + PropDeco, + __metadata("design:type", typeof Symbol === "function" ? Symbol : Object) +], B.prototype, "e"); +__decorate([ + PropDeco, + __metadata("design:type", Object) +], B.prototype, "f"); +__decorate([ + PropDeco, + __metadata("design:type", A) +], B.prototype, "g"); +__decorate([ + PropDeco, + __metadata("design:type", B) +], B.prototype, "h"); +__decorate([ + PropDeco, + __metadata("design:type", typeof Symbol === "function" ? Symbol : Object) +], B.prototype, "j"); diff --git a/tests/baselines/reference/metadataOfUnionWithNull.symbols b/tests/baselines/reference/metadataOfUnionWithNull.symbols index 13533a26699a2..13316bc7cf19e 100644 --- a/tests/baselines/reference/metadataOfUnionWithNull.symbols +++ b/tests/baselines/reference/metadataOfUnionWithNull.symbols @@ -53,4 +53,37 @@ class B { d: undefined | null; >d : Symbol(B.d, Decl(metadataOfUnionWithNull.ts, 22, 17)) + + @PropDeco +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) + + e: symbol | null; +>e : Symbol(B.e, Decl(metadataOfUnionWithNull.ts, 25, 24)) + + @PropDeco +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) + + f: symbol | A; +>f : Symbol(B.f, Decl(metadataOfUnionWithNull.ts, 28, 21)) +>A : Symbol(A, Decl(metadataOfUnionWithNull.ts, 0, 63)) + + @PropDeco +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) + + g: A | null; +>g : Symbol(B.g, Decl(metadataOfUnionWithNull.ts, 31, 18)) +>A : Symbol(A, Decl(metadataOfUnionWithNull.ts, 0, 63)) + + @PropDeco +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) + + h: null | B; +>h : Symbol(B.h, Decl(metadataOfUnionWithNull.ts, 34, 16)) +>B : Symbol(B, Decl(metadataOfUnionWithNull.ts, 3, 1)) + + @PropDeco +>PropDeco : Symbol(PropDeco, Decl(metadataOfUnionWithNull.ts, 0, 0)) + + j: null | symbol; +>j : Symbol(B.j, Decl(metadataOfUnionWithNull.ts, 37, 16)) } diff --git a/tests/baselines/reference/metadataOfUnionWithNull.types b/tests/baselines/reference/metadataOfUnionWithNull.types index e6037e16cb3b0..04a5b162d4c52 100644 --- a/tests/baselines/reference/metadataOfUnionWithNull.types +++ b/tests/baselines/reference/metadataOfUnionWithNull.types @@ -56,5 +56,42 @@ class B { d: undefined | null; >d : null +>null : null + + @PropDeco +>PropDeco : (target: Object, propKey: string | symbol) => void + + e: symbol | null; +>e : symbol +>null : null + + @PropDeco +>PropDeco : (target: Object, propKey: string | symbol) => void + + f: symbol | A; +>f : symbol | A +>A : A + + @PropDeco +>PropDeco : (target: Object, propKey: string | symbol) => void + + g: A | null; +>g : A +>A : A +>null : null + + @PropDeco +>PropDeco : (target: Object, propKey: string | symbol) => void + + h: null | B; +>h : B +>null : null +>B : B + + @PropDeco +>PropDeco : (target: Object, propKey: string | symbol) => void + + j: null | symbol; +>j : symbol >null : null } diff --git a/tests/cases/compiler/metadataOfUnionWithNull.ts b/tests/cases/compiler/metadataOfUnionWithNull.ts index 475024229fced..bb4d93189fc66 100644 --- a/tests/cases/compiler/metadataOfUnionWithNull.ts +++ b/tests/cases/compiler/metadataOfUnionWithNull.ts @@ -26,4 +26,19 @@ class B { @PropDeco d: undefined | null; + + @PropDeco + e: symbol | null; + + @PropDeco + f: symbol | A; + + @PropDeco + g: A | null; + + @PropDeco + h: null | B; + + @PropDeco + j: null | symbol; } \ No newline at end of file From 1045f3bffb5dd7d5cddd40de22eeda08d8cb95c6 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Tue, 20 Dec 2016 19:25:25 -0800 Subject: [PATCH 09/24] detach root files on project close if project language service is disabled (#13077) --- .../unittests/tsserverProjectSystem.ts | 35 +++++++++++++++++++ src/server/project.ts | 5 +-- 2 files changed, 38 insertions(+), 2 deletions(-) diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index 13d8a6bf824ef..d379b5bbf9c7f 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -1840,6 +1840,41 @@ namespace ts.projectSystem { assert.isFalse(service.externalProjects[0].languageServiceEnabled, "language service should be disabled - 2"); }); + it("files are properly detached when language service is disabled", () => { + const f1 = { + path: "/a/app.js", + content: "var x = 1" + }; + const f2 = { + path: "/a/largefile.js", + content: "" + }; + const f3 = { + path: "/a/lib.js", + content: "var x = 1" + }; + const config = { + path: "/a/tsconfig.json", + content: JSON.stringify({ compilerOptions: { allowJs: true } }) + }; + const host = createServerHost([f1, f2, f3, config]); + const originalGetFileSize = host.getFileSize; + host.getFileSize = (filePath: string) => + filePath === f2.path ? server.maxProgramSizeForNonTsFiles + 1 : originalGetFileSize.call(host, filePath); + + const projectService = createProjectService(host); + projectService.openClientFile(f1.path); + projectService.checkNumberOfProjects({ configuredProjects: 1 }); + + projectService.closeClientFile(f1.path); + projectService.checkNumberOfProjects({}); + + for (const f of [f2, f3]) { + const scriptInfo = projectService.getScriptInfoForNormalizedPath(server.toNormalizedPath(f.path)); + assert.equal(scriptInfo.containingProjects.length, 0, `expect 0 containing projects for '${f.path}'`) + } + }); + it("language service disabled events are triggered", () => { const f1 = { path: "/a/app.js", diff --git a/src/server/project.ts b/src/server/project.ts index 0037a470a49c8..6085ee05159e5 100644 --- a/src/server/project.ts +++ b/src/server/project.ts @@ -257,8 +257,9 @@ namespace ts.server { info.detachFromProject(this); } } - else { - // release all root files + if (!this.program || !this.languageServiceEnabled) { + // release all root files either if there is no program or language service is disabled. + // in the latter case set of root files can be larger than the set of files in program. for (const root of this.rootFiles) { root.detachFromProject(this); } From cddc72a25e1a1cf524be872e1c26d3f1c8b13ce0 Mon Sep 17 00:00:00 2001 From: Kagami Sascha Rosylight Date: Wed, 21 Dec 2016 20:58:52 +0900 Subject: [PATCH 10/24] always give container --- src/services/formatting/formatting.ts | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/services/formatting/formatting.ts b/src/services/formatting/formatting.ts index bcd8cebb017e7..78ddfa5c6e9d3 100644 --- a/src/services/formatting/formatting.ts +++ b/src/services/formatting/formatting.ts @@ -566,7 +566,7 @@ namespace ts.formatting { if (tokenInfo.token.end > node.end) { break; } - consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation); + consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node); } function processChildNode( @@ -617,7 +617,7 @@ namespace ts.formatting { break; } - consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation); + consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation, node); } if (!formattingScanner.isOnToken()) { @@ -673,11 +673,11 @@ namespace ts.formatting { computeIndentation(tokenInfo.token, startLine, Constants.Unknown, parent, parentDynamicIndentation, parentStartLine); listDynamicIndentation = getDynamicIndentation(parent, parentStartLine, indentation.indentation, indentation.delta); - consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation); + consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation, parent); } else { // consume any tokens that precede the list as child elements of 'node' using its indentation scope - consumeTokenAndAdvanceScanner(tokenInfo, parent, parentDynamicIndentation); + consumeTokenAndAdvanceScanner(tokenInfo, parent, parentDynamicIndentation, parent); } } } @@ -697,13 +697,13 @@ namespace ts.formatting { // without this check close paren will be interpreted as list end token for function expression which is wrong if (tokenInfo.token.kind === listEndToken && rangeContainsRange(parent, tokenInfo.token)) { // consume list end token - consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation); + consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation, parent); } } } } - function consumeTokenAndAdvanceScanner(currentTokenInfo: TokenInfo, parent: Node, dynamicIndentation: DynamicIndentation, container?: Node): void { + function consumeTokenAndAdvanceScanner(currentTokenInfo: TokenInfo, parent: Node, dynamicIndentation: DynamicIndentation, container: Node): void { Debug.assert(rangeContainsRange(parent, currentTokenInfo.token)); const lastTriviaWasNewLine = formattingScanner.lastTrailingTriviaWasNewLine(); From 54fb29b8b89f09f0c2d02e1679e4c84a26aab17a Mon Sep 17 00:00:00 2001 From: Kagami Sascha Rosylight Date: Wed, 21 Dec 2016 21:01:03 +0900 Subject: [PATCH 11/24] format generic type alias --- src/services/formatting/rules.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts index 2095f062bd103..89250820c7cb2 100644 --- a/src/services/formatting/rules.ts +++ b/src/services/formatting/rules.ts @@ -829,6 +829,7 @@ namespace ts.formatting { switch (parent.kind) { case SyntaxKind.TypeReference: case SyntaxKind.TypeAssertionExpression: + case SyntaxKind.TypeAliasDeclaration: case SyntaxKind.ClassDeclaration: case SyntaxKind.ClassExpression: case SyntaxKind.InterfaceDeclaration: From bc59d6242b562a8312f66e1e345076fdf6d18e38 Mon Sep 17 00:00:00 2001 From: Kagami Sascha Rosylight Date: Wed, 21 Dec 2016 21:01:28 +0900 Subject: [PATCH 12/24] format [P in keyof T] --- src/services/formatting/rules.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts index 89250820c7cb2..408b4683fe908 100644 --- a/src/services/formatting/rules.ts +++ b/src/services/formatting/rules.ts @@ -358,7 +358,7 @@ namespace ts.formatting { this.NoSpaceAfterModuleImport = new Rule(RuleDescriptor.create2(Shared.TokenRange.FromTokens([SyntaxKind.ModuleKeyword, SyntaxKind.RequireKeyword]), SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Delete)); // Add a space around certain TypeScript keywords - this.SpaceAfterCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.AbstractKeyword, SyntaxKind.ClassKeyword, SyntaxKind.DeclareKeyword, SyntaxKind.DefaultKeyword, SyntaxKind.EnumKeyword, SyntaxKind.ExportKeyword, SyntaxKind.ExtendsKeyword, SyntaxKind.GetKeyword, SyntaxKind.ImplementsKeyword, SyntaxKind.ImportKeyword, SyntaxKind.InterfaceKeyword, SyntaxKind.ModuleKeyword, SyntaxKind.NamespaceKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.PublicKeyword, SyntaxKind.ProtectedKeyword, SyntaxKind.SetKeyword, SyntaxKind.StaticKeyword, SyntaxKind.TypeKeyword, SyntaxKind.FromKeyword]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Space)); + this.SpaceAfterCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.AbstractKeyword, SyntaxKind.ClassKeyword, SyntaxKind.DeclareKeyword, SyntaxKind.DefaultKeyword, SyntaxKind.EnumKeyword, SyntaxKind.ExportKeyword, SyntaxKind.ExtendsKeyword, SyntaxKind.GetKeyword, SyntaxKind.ImplementsKeyword, SyntaxKind.ImportKeyword, SyntaxKind.InterfaceKeyword, SyntaxKind.ModuleKeyword, SyntaxKind.NamespaceKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.PublicKeyword, SyntaxKind.ProtectedKeyword, SyntaxKind.SetKeyword, SyntaxKind.StaticKeyword, SyntaxKind.TypeKeyword, SyntaxKind.FromKeyword, SyntaxKind.KeyOfKeyword]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Space)); this.SpaceBeforeCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.Any, Shared.TokenRange.FromTokens([SyntaxKind.ExtendsKeyword, SyntaxKind.ImplementsKeyword, SyntaxKind.FromKeyword])), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Space)); // Treat string literals in module names as identifiers, and add a space between the literal and the opening Brace braces, e.g.: module "m2" { @@ -575,6 +575,8 @@ namespace ts.formatting { return context.currentTokenSpan.kind === SyntaxKind.EqualsToken || context.nextTokenSpan.kind === SyntaxKind.EqualsToken; // "in" keyword in for (let x in []) { } case SyntaxKind.ForInStatement: + // "in" keyword in [P in keyof T]: T[P] + case SyntaxKind.TypeParameter: return context.currentTokenSpan.kind === SyntaxKind.InKeyword || context.nextTokenSpan.kind === SyntaxKind.InKeyword; // Technically, "of" is not a binary operator, but format it the same way as "in" case SyntaxKind.ForOfStatement: From f4c33aaec4537deecf4f5a0587616b386be5be2f Mon Sep 17 00:00:00 2001 From: Kagami Sascha Rosylight Date: Wed, 21 Dec 2016 21:01:47 +0900 Subject: [PATCH 13/24] indent inside mapped type --- src/services/formatting/formatting.ts | 6 ++++-- src/services/formatting/smartIndenter.ts | 1 + tests/cases/fourslash/formattingMappedType.ts | 12 ++++++++++++ 3 files changed, 17 insertions(+), 2 deletions(-) create mode 100644 tests/cases/fourslash/formattingMappedType.ts diff --git a/src/services/formatting/formatting.ts b/src/services/formatting/formatting.ts index 78ddfa5c6e9d3..8350b2a8dc844 100644 --- a/src/services/formatting/formatting.ts +++ b/src/services/formatting/formatting.ts @@ -488,14 +488,16 @@ namespace ts.formatting { // open and close brace, 'else' and 'while' (in do statement) tokens has indentation of the parent case SyntaxKind.OpenBraceToken: case SyntaxKind.CloseBraceToken: - case SyntaxKind.OpenBracketToken: - case SyntaxKind.CloseBracketToken: case SyntaxKind.OpenParenToken: case SyntaxKind.CloseParenToken: case SyntaxKind.ElseKeyword: case SyntaxKind.WhileKeyword: case SyntaxKind.AtToken: return indentation; + case SyntaxKind.OpenBracketToken: + case SyntaxKind.CloseBracketToken: + return (container.kind === SyntaxKind.MappedType) ? + indentation + getEffectiveDelta(delta, container) : indentation; default: // if token line equals to the line of containing node (this is a first token in the node) - use node indentation return nodeStartLine !== line ? indentation + getEffectiveDelta(delta, container) : indentation; diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts index 84f83a9c7dbd7..eb9e1ba04c531 100644 --- a/src/services/formatting/smartIndenter.ts +++ b/src/services/formatting/smartIndenter.ts @@ -438,6 +438,7 @@ namespace ts.formatting { case SyntaxKind.ModuleBlock: case SyntaxKind.ObjectLiteralExpression: case SyntaxKind.TypeLiteral: + case SyntaxKind.MappedType: case SyntaxKind.TupleType: case SyntaxKind.CaseBlock: case SyntaxKind.DefaultClause: diff --git a/tests/cases/fourslash/formattingMappedType.ts b/tests/cases/fourslash/formattingMappedType.ts new file mode 100644 index 0000000000000..a33d948a9c340 --- /dev/null +++ b/tests/cases/fourslash/formattingMappedType.ts @@ -0,0 +1,12 @@ +/// + +/////*generic*/type t < T > = { +/////*map*/ [ P in keyof T ] : T [ P ] +////}; + + +format.document(); +goTo.marker("generic"); +verify.currentLineContentIs("type t = {"); +goTo.marker("map"); +verify.currentLineContentIs(" [P in keyof T]: T[P]"); \ No newline at end of file From a4ec7d66eb94a651b739b057fd6e2b39552e8137 Mon Sep 17 00:00:00 2001 From: Kagami Sascha Rosylight Date: Wed, 21 Dec 2016 21:50:45 +0900 Subject: [PATCH 14/24] unindent dangling closing token --- src/services/formatting/formatting.ts | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/src/services/formatting/formatting.ts b/src/services/formatting/formatting.ts index 78ddfa5c6e9d3..41630a7793593 100644 --- a/src/services/formatting/formatting.ts +++ b/src/services/formatting/formatting.ts @@ -496,10 +496,19 @@ namespace ts.formatting { case SyntaxKind.WhileKeyword: case SyntaxKind.AtToken: return indentation; - default: - // if token line equals to the line of containing node (this is a first token in the node) - use node indentation - return nodeStartLine !== line ? indentation + getEffectiveDelta(delta, container) : indentation; + case SyntaxKind.SlashToken: + case SyntaxKind.GreaterThanToken: { + if (container.kind === SyntaxKind.JsxOpeningElement || + container.kind === SyntaxKind.JsxClosingElement || + container.kind === SyntaxKind.JsxSelfClosingElement + ) { + return indentation; + } + break; + } } + // if token line equals to the line of containing node (this is a first token in the node) - use node indentation + return nodeStartLine !== line ? indentation + getEffectiveDelta(delta, container) : indentation; }, getIndentation: () => indentation, getDelta: child => getEffectiveDelta(delta, child), From ba7c1a13c3b9ea49d034ca07f42317e6a2bb158d Mon Sep 17 00:00:00 2001 From: Kagami Sascha Rosylight Date: Wed, 21 Dec 2016 21:54:40 +0900 Subject: [PATCH 15/24] do not insert space after function expressions --- src/services/formatting/rules.ts | 9 ++++++++- .../cases/fourslash/formatVariableDeclarationList.ts | 2 +- tests/cases/fourslash/formattingJsxElements.ts | 11 ++++++++--- 3 files changed, 17 insertions(+), 5 deletions(-) diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts index 2095f062bd103..f29890806b5d7 100644 --- a/src/services/formatting/rules.ts +++ b/src/services/formatting/rules.ts @@ -705,11 +705,18 @@ namespace ts.formatting { case SyntaxKind.ClassDeclaration: case SyntaxKind.ModuleDeclaration: case SyntaxKind.EnumDeclaration: - case SyntaxKind.Block: case SyntaxKind.CatchClause: case SyntaxKind.ModuleBlock: case SyntaxKind.SwitchStatement: return true; + case SyntaxKind.Block: { + const blockParent = context.currentTokenParent.parent; + if (blockParent.kind !== SyntaxKind.ArrowFunction && + blockParent.kind !== SyntaxKind.FunctionExpression) + { + return true; + } + } } return false; } diff --git a/tests/cases/fourslash/formatVariableDeclarationList.ts b/tests/cases/fourslash/formatVariableDeclarationList.ts index 37392d38c62cc..089eceb1684ba 100644 --- a/tests/cases/fourslash/formatVariableDeclarationList.ts +++ b/tests/cases/fourslash/formatVariableDeclarationList.ts @@ -37,4 +37,4 @@ verify.currentLineContentIs(" x = 'Foo';"); goTo.marker("11"); verify.currentLineContentIs(" return fun;"); goTo.marker("12"); -verify.currentLineContentIs(" } (fun1));"); +verify.currentLineContentIs(" }(fun1));"); \ No newline at end of file diff --git a/tests/cases/fourslash/formattingJsxElements.ts b/tests/cases/fourslash/formattingJsxElements.ts index 2b3b396ed4c44..a27bc8094565e 100644 --- a/tests/cases/fourslash/formattingJsxElements.ts +++ b/tests/cases/fourslash/formattingJsxElements.ts @@ -72,6 +72,8 @@ ////) ;/*closingParenInJsxElement2*/ ////;/*jsxExpressionSpaces*/ ////;/*jsxExpressionSpaces2*/ +//// {}}/*jsxExpressionSpaces3*/ +/////>;/*jsxDanglingSelfClosingToken*/ format.document(); goTo.marker("autoformat"); @@ -120,8 +122,7 @@ goTo.marker("expressionIndent"); verify.indentationIs(12); goTo.marker("danglingBracketAutoformat") -// TODO: verify.currentLineContentIs(" >"); -verify.currentLineContentIs(" >"); +verify.currentLineContentIs(" >"); goTo.marker("closingTagAutoformat"); verify.currentLineContentIs(" "); @@ -145,4 +146,8 @@ verify.currentLineContentIs(") ;"); goTo.marker("jsxExpressionSpaces"); verify.currentLineContentIs(";"); goTo.marker("jsxExpressionSpaces2"); -verify.currentLineContentIs(";"); \ No newline at end of file +verify.currentLineContentIs(";"); +goTo.marker("jsxExpressionSpaces3"); +verify.currentLineContentIs(" { }}"); +goTo.marker("jsxDanglingSelfClosingToken"); +verify.currentLineContentIs("/>;"); \ No newline at end of file From 2576ea1cf5d03f9ffa6471539f338c69279156e9 Mon Sep 17 00:00:00 2001 From: Kagami Sascha Rosylight Date: Wed, 21 Dec 2016 22:16:00 +0900 Subject: [PATCH 16/24] fix linter alert --- src/services/formatting/rules.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts index f29890806b5d7..18125932a110a 100644 --- a/src/services/formatting/rules.ts +++ b/src/services/formatting/rules.ts @@ -712,8 +712,8 @@ namespace ts.formatting { case SyntaxKind.Block: { const blockParent = context.currentTokenParent.parent; if (blockParent.kind !== SyntaxKind.ArrowFunction && - blockParent.kind !== SyntaxKind.FunctionExpression) - { + blockParent.kind !== SyntaxKind.FunctionExpression + ) { return true; } } From 32568b3fc2f6a33b739db0251b034fb36a893e17 Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Wed, 21 Dec 2016 09:45:04 -0800 Subject: [PATCH 17/24] Test case when module member is object spread pattern --- .../unusedLocalsAndObjectSpread2.errors.txt | 35 ++++++++++++++++++ .../reference/unusedLocalsAndObjectSpread2.js | 37 +++++++++++++++++++ .../compiler/unusedLocalsAndObjectSpread2.ts | 18 +++++++++ 3 files changed, 90 insertions(+) create mode 100644 tests/baselines/reference/unusedLocalsAndObjectSpread2.errors.txt create mode 100644 tests/baselines/reference/unusedLocalsAndObjectSpread2.js create mode 100644 tests/cases/compiler/unusedLocalsAndObjectSpread2.ts diff --git a/tests/baselines/reference/unusedLocalsAndObjectSpread2.errors.txt b/tests/baselines/reference/unusedLocalsAndObjectSpread2.errors.txt new file mode 100644 index 0000000000000..0908f5ce3b9c0 --- /dev/null +++ b/tests/baselines/reference/unusedLocalsAndObjectSpread2.errors.txt @@ -0,0 +1,35 @@ +tests/cases/compiler/unusedLocalsAndObjectSpread2.ts(4,5): error TS6133: 'children' is declared but never used. +tests/cases/compiler/unusedLocalsAndObjectSpread2.ts(5,13): error TS6133: '_a' is declared but never used. +tests/cases/compiler/unusedLocalsAndObjectSpread2.ts(6,6): error TS6133: 'rest' is declared but never used. +tests/cases/compiler/unusedLocalsAndObjectSpread2.ts(9,10): error TS6133: 'foo' is declared but never used. +tests/cases/compiler/unusedLocalsAndObjectSpread2.ts(13,8): error TS6133: 'rest' is declared but never used. + + +==== tests/cases/compiler/unusedLocalsAndObjectSpread2.ts (5 errors) ==== + + declare let props: any; + const { + children, // here! + ~~~~~~~~ +!!! error TS6133: 'children' is declared but never used. + active: _a, // here! + ~~ +!!! error TS6133: '_a' is declared but never used. + ...rest, + ~~~~ +!!! error TS6133: 'rest' is declared but never used. + } = props; + + function foo() { + ~~~ +!!! error TS6133: 'foo' is declared but never used. + const { + children, + active: _a, + ...rest, + ~~~~ +!!! error TS6133: 'rest' is declared but never used. + } = props; + } + + export const asdf = 123; \ No newline at end of file diff --git a/tests/baselines/reference/unusedLocalsAndObjectSpread2.js b/tests/baselines/reference/unusedLocalsAndObjectSpread2.js new file mode 100644 index 0000000000000..e6cd890abb7c9 --- /dev/null +++ b/tests/baselines/reference/unusedLocalsAndObjectSpread2.js @@ -0,0 +1,37 @@ +//// [unusedLocalsAndObjectSpread2.ts] + +declare let props: any; +const { + children, // here! + active: _a, // here! + ...rest, +} = props; + +function foo() { + const { + children, + active: _a, + ...rest, + } = props; +} + +export const asdf = 123; + +//// [unusedLocalsAndObjectSpread2.js] +"use strict"; +var __rest = (this && this.__rest) || function (s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0) + t[p[i]] = s[p[i]]; + return t; +}; +var children = props.children, // here! +_a = props.active, // here! +rest = __rest(props, ["children", "active"]); +function foo() { + var children = props.children, _a = props.active, rest = __rest(props, ["children", "active"]); +} +exports.asdf = 123; diff --git a/tests/cases/compiler/unusedLocalsAndObjectSpread2.ts b/tests/cases/compiler/unusedLocalsAndObjectSpread2.ts new file mode 100644 index 0000000000000..e55c2042a4181 --- /dev/null +++ b/tests/cases/compiler/unusedLocalsAndObjectSpread2.ts @@ -0,0 +1,18 @@ +//@noUnusedLocals:true + +declare let props: any; +const { + children, // here! + active: _a, // here! + ...rest, +} = props; + +function foo() { + const { + children, + active: _a, + ...rest, + } = props; +} + +export const asdf = 123; \ No newline at end of file From 330cceda17dcb2fbad6d85b257093e57603265bf Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Wed, 21 Dec 2016 10:02:28 -0800 Subject: [PATCH 18/24] cache results of module resolution for non-relative module names (#13047) * cache results of module resolution for non-relative module names * use cache to short-circuit failures --- src/compiler/moduleNameResolver.ts | 206 +++++++++++++++--- .../reference/cachedModuleResolution1.js | 16 ++ .../reference/cachedModuleResolution1.symbols | 13 ++ .../cachedModuleResolution1.trace.json | 46 ++++ .../reference/cachedModuleResolution1.types | 13 ++ .../reference/cachedModuleResolution2.js | 17 ++ .../reference/cachedModuleResolution2.symbols | 13 ++ .../cachedModuleResolution2.trace.json | 46 ++++ .../reference/cachedModuleResolution2.types | 13 ++ .../reference/cachedModuleResolution3.js | 16 ++ .../reference/cachedModuleResolution3.symbols | 13 ++ .../cachedModuleResolution3.trace.json | 21 ++ .../reference/cachedModuleResolution3.types | 13 ++ .../reference/cachedModuleResolution4.js | 17 ++ .../reference/cachedModuleResolution4.symbols | 13 ++ .../cachedModuleResolution4.trace.json | 21 ++ .../reference/cachedModuleResolution4.types | 13 ++ .../reference/cachedModuleResolution5.js | 16 ++ .../reference/cachedModuleResolution5.symbols | 13 ++ .../cachedModuleResolution5.trace.json | 46 ++++ .../reference/cachedModuleResolution5.types | 13 ++ .../cachedModuleResolution6.errors.txt | 14 ++ .../reference/cachedModuleResolution6.js | 13 ++ .../cachedModuleResolution6.trace.json | 102 +++++++++ .../cachedModuleResolution7.errors.txt | 15 ++ .../reference/cachedModuleResolution7.js | 14 ++ .../cachedModuleResolution7.trace.json | 92 ++++++++ .../cachedModuleResolution8.errors.txt | 14 ++ .../reference/cachedModuleResolution8.js | 13 ++ .../cachedModuleResolution8.trace.json | 57 +++++ .../cachedModuleResolution9.errors.txt | 16 ++ .../reference/cachedModuleResolution9.js | 15 ++ .../cachedModuleResolution9.trace.json | 47 ++++ .../cases/compiler/cachedModuleResolution1.ts | 11 + .../cases/compiler/cachedModuleResolution2.ts | 11 + .../cases/compiler/cachedModuleResolution3.ts | 11 + .../cases/compiler/cachedModuleResolution4.ts | 11 + .../cases/compiler/cachedModuleResolution5.ts | 11 + .../cases/compiler/cachedModuleResolution6.ts | 8 + .../cases/compiler/cachedModuleResolution7.ts | 8 + .../cases/compiler/cachedModuleResolution8.ts | 8 + .../cases/compiler/cachedModuleResolution9.ts | 9 + 42 files changed, 1067 insertions(+), 31 deletions(-) create mode 100644 tests/baselines/reference/cachedModuleResolution1.js create mode 100644 tests/baselines/reference/cachedModuleResolution1.symbols create mode 100644 tests/baselines/reference/cachedModuleResolution1.trace.json create mode 100644 tests/baselines/reference/cachedModuleResolution1.types create mode 100644 tests/baselines/reference/cachedModuleResolution2.js create mode 100644 tests/baselines/reference/cachedModuleResolution2.symbols create mode 100644 tests/baselines/reference/cachedModuleResolution2.trace.json create mode 100644 tests/baselines/reference/cachedModuleResolution2.types create mode 100644 tests/baselines/reference/cachedModuleResolution3.js create mode 100644 tests/baselines/reference/cachedModuleResolution3.symbols create mode 100644 tests/baselines/reference/cachedModuleResolution3.trace.json create mode 100644 tests/baselines/reference/cachedModuleResolution3.types create mode 100644 tests/baselines/reference/cachedModuleResolution4.js create mode 100644 tests/baselines/reference/cachedModuleResolution4.symbols create mode 100644 tests/baselines/reference/cachedModuleResolution4.trace.json create mode 100644 tests/baselines/reference/cachedModuleResolution4.types create mode 100644 tests/baselines/reference/cachedModuleResolution5.js create mode 100644 tests/baselines/reference/cachedModuleResolution5.symbols create mode 100644 tests/baselines/reference/cachedModuleResolution5.trace.json create mode 100644 tests/baselines/reference/cachedModuleResolution5.types create mode 100644 tests/baselines/reference/cachedModuleResolution6.errors.txt create mode 100644 tests/baselines/reference/cachedModuleResolution6.js create mode 100644 tests/baselines/reference/cachedModuleResolution6.trace.json create mode 100644 tests/baselines/reference/cachedModuleResolution7.errors.txt create mode 100644 tests/baselines/reference/cachedModuleResolution7.js create mode 100644 tests/baselines/reference/cachedModuleResolution7.trace.json create mode 100644 tests/baselines/reference/cachedModuleResolution8.errors.txt create mode 100644 tests/baselines/reference/cachedModuleResolution8.js create mode 100644 tests/baselines/reference/cachedModuleResolution8.trace.json create mode 100644 tests/baselines/reference/cachedModuleResolution9.errors.txt create mode 100644 tests/baselines/reference/cachedModuleResolution9.js create mode 100644 tests/baselines/reference/cachedModuleResolution9.trace.json create mode 100644 tests/cases/compiler/cachedModuleResolution1.ts create mode 100644 tests/cases/compiler/cachedModuleResolution2.ts create mode 100644 tests/cases/compiler/cachedModuleResolution3.ts create mode 100644 tests/cases/compiler/cachedModuleResolution4.ts create mode 100644 tests/cases/compiler/cachedModuleResolution5.ts create mode 100644 tests/cases/compiler/cachedModuleResolution6.ts create mode 100644 tests/cases/compiler/cachedModuleResolution7.ts create mode 100644 tests/cases/compiler/cachedModuleResolution8.ts create mode 100644 tests/cases/compiler/cachedModuleResolution9.ts diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts index c2fcbddaa61dc..be8f4d6f0cb46 100644 --- a/src/compiler/moduleNameResolver.ts +++ b/src/compiler/moduleNameResolver.ts @@ -149,6 +149,7 @@ namespace ts { if (host.directoryExists(atTypes)) { (typeRoots || (typeRoots = [])).push(atTypes); } + return undefined; }); return typeRoots; } @@ -237,7 +238,8 @@ namespace ts { if (traceEnabled) { trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup); } - resolvedFile = resolvedTypeScriptOnly(loadModuleFromNodeModules(Extensions.DtsOnly, typeReferenceDirectiveName, initialLocationForSecondaryLookup, failedLookupLocations, moduleResolutionState)); + const result = loadModuleFromNodeModules(Extensions.DtsOnly, typeReferenceDirectiveName, initialLocationForSecondaryLookup, failedLookupLocations, moduleResolutionState, /*cache*/ undefined); + resolvedFile = resolvedTypeScriptOnly(result && result.value); if (!resolvedFile && traceEnabled) { trace(host, Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName); } @@ -293,24 +295,120 @@ namespace ts { * Cached module resolutions per containing directory. * This assumes that any module id will have the same resolution for sibling files located in the same folder. */ - export interface ModuleResolutionCache { + export interface ModuleResolutionCache extends NonRelativeModuleNameResolutionCache { getOrCreateCacheForDirectory(directoryName: string): Map; } - export function createModuleResolutionCache(currentDirectory: string, getCanonicalFileName: (s: string) => string) { - const map = createFileMap>(); + /** + * Stored map from non-relative module name to a table: directory -> result of module lookup in this directory + * We support only non-relative module names because resolution of relative module names is usually more deterministic and thus less expensive. + */ + export interface NonRelativeModuleNameResolutionCache { + getOrCreateCacheForModuleName(nonRelativeModuleName: string): PerModuleNameCache; + } + + export interface PerModuleNameCache { + get(directory: string): ResolvedModuleWithFailedLookupLocations; + set(directory: string, result: ResolvedModuleWithFailedLookupLocations): void; + } + + export function createModuleResolutionCache(currentDirectory: string, getCanonicalFileName: (s: string) => string): ModuleResolutionCache { + const directoryToModuleNameMap = createFileMap>(); + const moduleNameToDirectoryMap = createMap(); - return { getOrCreateCacheForDirectory }; + return { getOrCreateCacheForDirectory, getOrCreateCacheForModuleName }; function getOrCreateCacheForDirectory(directoryName: string) { const path = toPath(directoryName, currentDirectory, getCanonicalFileName); - let perFolderCache = map.get(path); + let perFolderCache = directoryToModuleNameMap.get(path); if (!perFolderCache) { perFolderCache = createMap(); - map.set(path, perFolderCache); + directoryToModuleNameMap.set(path, perFolderCache); } return perFolderCache; } + + function getOrCreateCacheForModuleName(nonRelativeModuleName: string) { + if (!moduleHasNonRelativeName(nonRelativeModuleName)) { + return undefined; + } + let perModuleNameCache = moduleNameToDirectoryMap[nonRelativeModuleName]; + if (!perModuleNameCache) { + moduleNameToDirectoryMap[nonRelativeModuleName] = perModuleNameCache = createPerModuleNameCache(); + } + return perModuleNameCache; + } + + function createPerModuleNameCache(): PerModuleNameCache { + const directoryPathMap = createFileMap(); + + return { get, set }; + + function get(directory: string): ResolvedModuleWithFailedLookupLocations { + return directoryPathMap.get(toPath(directory, currentDirectory, getCanonicalFileName)); + } + + /** + * At first this function add entry directory -> module resolution result to the table. + * Then it computes the set of parent folders for 'directory' that should have the same module resolution result + * and for every parent folder in set it adds entry: parent -> module resolution. . + * Lets say we first directory name: /a/b/c/d/e and resolution result is: /a/b/bar.ts. + * Set of parent folders that should have the same result will be: + * [ + * /a/b/c/d, /a/b/c, /a/b + * ] + * this means that request for module resolution from file in any of these folder will be immediately found in cache. + */ + function set(directory: string, result: ResolvedModuleWithFailedLookupLocations): void { + const path = toPath(directory, currentDirectory, getCanonicalFileName); + // if entry is already in cache do nothing + if (directoryPathMap.contains(path)) { + return; + } + directoryPathMap.set(path, result); + + const resolvedFileName = result.resolvedModule && result.resolvedModule.resolvedFileName; + // find common prefix between directory and resolved file name + // this common prefix should be the shorted path that has the same resolution + // directory: /a/b/c/d/e + // resolvedFileName: /a/b/foo.d.ts + const commonPrefix = getCommonPrefix(path, resolvedFileName); + let current = path; + while (true) { + const parent = getDirectoryPath(current); + if (parent === current || directoryPathMap.contains(parent)) { + break; + } + directoryPathMap.set(parent, result); + current = parent; + + if (current == commonPrefix) { + break; + } + } + } + + function getCommonPrefix(directory: Path, resolution: string) { + if (resolution === undefined) { + return undefined; + } + const resolutionDirectory = toPath(getDirectoryPath(resolution), currentDirectory, getCanonicalFileName); + + // find first position where directory and resolution differs + let i = 0; + while (i < Math.min(directory.length, resolutionDirectory.length) && directory.charCodeAt(i) === resolutionDirectory.charCodeAt(i)) { + i++; + } + + // find last directory separator before position i + const sep = directory.lastIndexOf(directorySeparator, i); + if (sep < 0) { + return undefined; + } + + return directory.substr(0, sep); + } + } } export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache): ResolvedModuleWithFailedLookupLocations { @@ -318,7 +416,8 @@ namespace ts { if (traceEnabled) { trace(host, Diagnostics.Resolving_module_0_from_1, moduleName, containingFile); } - const perFolderCache = cache && cache.getOrCreateCacheForDirectory(getDirectoryPath(containingFile)); + const containingDirectory = getDirectoryPath(containingFile); + let perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory); let result = perFolderCache && perFolderCache[moduleName]; if (result) { @@ -342,15 +441,20 @@ namespace ts { switch (moduleResolution) { case ModuleResolutionKind.NodeJs: - result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host); + result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache); break; case ModuleResolutionKind.Classic: - result = classicNameResolver(moduleName, containingFile, compilerOptions, host); + result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache); break; } if (perFolderCache) { perFolderCache[moduleName] = result; + // put result in per-module name cache + const perModuleNameCache = cache.getOrCreateCacheForModuleName(moduleName); + if (perModuleNameCache) { + perModuleNameCache.set(containingDirectory, result); + } } } @@ -574,7 +678,7 @@ namespace ts { } } - export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations { + export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache): ResolvedModuleWithFailedLookupLocations { const containingDirectory = getDirectoryPath(containingFile); const traceEnabled = isTraceEnabled(compilerOptions, host); @@ -582,30 +686,30 @@ namespace ts { const state: ModuleResolutionState = { compilerOptions, host, traceEnabled }; const result = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript); - if (result) { - const { resolved, isExternalLibraryImport } = result; + if (result && result.value) { + const { resolved, isExternalLibraryImport } = result.value; return createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations); } return { resolvedModule: undefined, failedLookupLocations }; - function tryResolve(extensions: Extensions): { resolved: Resolved, isExternalLibraryImport: boolean } | undefined { + function tryResolve(extensions: Extensions): SearchResult<{ resolved: Resolved, isExternalLibraryImport: boolean }> { const resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, nodeLoadModuleByRelativeName, failedLookupLocations, state); if (resolved) { - return { resolved, isExternalLibraryImport: false }; + return toSearchResult({ resolved, isExternalLibraryImport: false }); } if (moduleHasNonRelativeName(moduleName)) { if (traceEnabled) { trace(host, Diagnostics.Loading_module_0_from_node_modules_folder, moduleName); } - const resolved = loadModuleFromNodeModules(extensions, moduleName, containingDirectory, failedLookupLocations, state); + const resolved = loadModuleFromNodeModules(extensions, moduleName, containingDirectory, failedLookupLocations, state, cache); // For node_modules lookups, get the real path so that multiple accesses to an `npm link`-ed module do not create duplicate files. - return resolved && { resolved: { path: realpath(resolved.path, host, traceEnabled), extension: resolved.extension }, isExternalLibraryImport: true }; + return resolved && { value: resolved.value && { resolved: { path: realpath(resolved.value.path, host, traceEnabled), extension: resolved.value.extension }, isExternalLibraryImport: true } }; } else { const candidate = normalizePath(combinePaths(containingDirectory, moduleName)); const resolved = nodeLoadModuleByRelativeName(extensions, candidate, failedLookupLocations, /*onlyRecordFailures*/ false, state); - return resolved && { resolved, isExternalLibraryImport: false }; + return resolved && toSearchResult({ resolved, isExternalLibraryImport: false }); } } } @@ -775,18 +879,23 @@ namespace ts { loadNodeModuleFromDirectory(extensions, candidate, failedLookupLocations, !nodeModulesFolderExists, state); } - function loadModuleFromNodeModules(extensions: Extensions, moduleName: string, directory: string, failedLookupLocations: Push, state: ModuleResolutionState): Resolved | undefined { - return loadModuleFromNodeModulesWorker(extensions, moduleName, directory, failedLookupLocations, state, /*typesOnly*/ false); + function loadModuleFromNodeModules(extensions: Extensions, moduleName: string, directory: string, failedLookupLocations: Push, state: ModuleResolutionState, cache: NonRelativeModuleNameResolutionCache): SearchResult { + return loadModuleFromNodeModulesWorker(extensions, moduleName, directory, failedLookupLocations, state, /*typesOnly*/ false, cache); } - function loadModuleFromNodeModulesAtTypes(moduleName: string, directory: string, failedLookupLocations: Push, state: ModuleResolutionState): Resolved | undefined { + function loadModuleFromNodeModulesAtTypes(moduleName: string, directory: string, failedLookupLocations: Push, state: ModuleResolutionState): SearchResult { // Extensions parameter here doesn't actually matter, because typesOnly ensures we're just doing @types lookup, which is always DtsOnly. - return loadModuleFromNodeModulesWorker(Extensions.DtsOnly, moduleName, directory, failedLookupLocations, state, /*typesOnly*/ true); + return loadModuleFromNodeModulesWorker(Extensions.DtsOnly, moduleName, directory, failedLookupLocations, state, /*typesOnly*/ true, /*cache*/ undefined); } - function loadModuleFromNodeModulesWorker(extensions: Extensions, moduleName: string, directory: string, failedLookupLocations: Push, state: ModuleResolutionState, typesOnly: boolean): Resolved | undefined { + function loadModuleFromNodeModulesWorker(extensions: Extensions, moduleName: string, directory: string, failedLookupLocations: Push, state: ModuleResolutionState, typesOnly: boolean, cache: NonRelativeModuleNameResolutionCache): SearchResult { + const perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName); return forEachAncestorDirectory(normalizeSlashes(directory), ancestorDirectory => { if (getBaseFileName(ancestorDirectory) !== "node_modules") { - return loadModuleFromNodeModulesOneLevel(extensions, moduleName, ancestorDirectory, failedLookupLocations, state, typesOnly); + const resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state.traceEnabled, state.host); + if (resolutionFromCache) { + return resolutionFromCache; + } + return toSearchResult(loadModuleFromNodeModulesOneLevel(extensions, moduleName, ancestorDirectory, failedLookupLocations, state, typesOnly)); } }); } @@ -802,26 +911,41 @@ namespace ts { } } - export function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations { + function tryFindNonRelativeModuleNameInCache(cache: PerModuleNameCache | undefined, moduleName: string, containingDirectory: string, traceEnabled: boolean, host: ModuleResolutionHost): SearchResult { + const result = cache && cache.get(containingDirectory); + if (result) { + if (traceEnabled) { + trace(host, Diagnostics.Resolution_for_module_0_was_found_in_cache, moduleName) + } + return { value: result.resolvedModule && { path: result.resolvedModule.resolvedFileName, extension: result.resolvedModule.extension } }; + } + } + + export function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: NonRelativeModuleNameResolutionCache): ResolvedModuleWithFailedLookupLocations { const traceEnabled = isTraceEnabled(compilerOptions, host); const state: ModuleResolutionState = { compilerOptions, host, traceEnabled }; const failedLookupLocations: string[] = []; const containingDirectory = getDirectoryPath(containingFile); const resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript); - return createResolvedModuleWithFailedLookupLocations(resolved, /*isExternalLibraryImport*/ false, failedLookupLocations); + return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, /*isExternalLibraryImport*/ false, failedLookupLocations); - function tryResolve(extensions: Extensions): Resolved | undefined { + function tryResolve(extensions: Extensions): SearchResult { const resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFile, failedLookupLocations, state); if (resolvedUsingSettings) { - return resolvedUsingSettings; + return { value: resolvedUsingSettings }; } + const perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName); if (moduleHasNonRelativeName(moduleName)) { // Climb up parent directories looking for a module. const resolved = forEachAncestorDirectory(containingDirectory, directory => { + const resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, directory, traceEnabled, host); + if (resolutionFromCache) { + return resolutionFromCache; + } const searchName = normalizePath(combinePaths(directory, moduleName)); - return loadModuleFromFile(extensions, searchName, failedLookupLocations, /*onlyRecordFailures*/ false, state); + return toSearchResult(loadModuleFromFile(extensions, searchName, failedLookupLocations, /*onlyRecordFailures*/ false, state)); }); if (resolved) { return resolved; @@ -833,7 +957,7 @@ namespace ts { } else { const candidate = normalizePath(combinePaths(containingDirectory, moduleName)); - return loadModuleFromFile(extensions, candidate, failedLookupLocations, /*onlyRecordFailures*/ false, state); + return toSearchResult(loadModuleFromFile(extensions, candidate, failedLookupLocations, /*onlyRecordFailures*/ false, state)); } } } @@ -854,8 +978,28 @@ namespace ts { return createResolvedModuleWithFailedLookupLocations(resolved, /*isExternalLibraryImport*/ true, failedLookupLocations); } + /** + * Represents result of search. Normally when searching among several alternatives we treat value `undefined` as indicator + * that search fails and we should try another option. + * However this does not allow us to represent final result that should be used instead of further searching (i.e. a final result that was found in cache). + * SearchResult is used to deal with this issue, its values represents following outcomes: + * - undefined - not found, continue searching + * - { value: undefined } - not found - stop searching + * - { value: } - found - stop searching + */ + type SearchResult = { value: T | undefined } | undefined; + + /** + * Wraps value to SearchResult. + * @returns undefined if value is undefined or { value } otherwise + */ + function toSearchResult(value: T | undefined): SearchResult { + return value !== undefined ? { value } : undefined; + } + + /** Calls `callback` on `directory` and every ancestor directory it has, returning the first defined result. */ - function forEachAncestorDirectory(directory: string, callback: (directory: string) => T | undefined): T | undefined { + function forEachAncestorDirectory(directory: string, callback: (directory: string) => SearchResult): SearchResult { while (true) { const result = callback(directory); if (result !== undefined) { diff --git a/tests/baselines/reference/cachedModuleResolution1.js b/tests/baselines/reference/cachedModuleResolution1.js new file mode 100644 index 0000000000000..9071b60d6c1bb --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution1.js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/cachedModuleResolution1.ts] //// + +//// [foo.d.ts] + +export declare let x: number + +//// [app.ts] +import {x} from "foo"; + +//// [lib.ts] +import {x} from "foo"; + +//// [app.js] +"use strict"; +//// [lib.js] +"use strict"; diff --git a/tests/baselines/reference/cachedModuleResolution1.symbols b/tests/baselines/reference/cachedModuleResolution1.symbols new file mode 100644 index 0000000000000..f7d3c474a56bb --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution1.symbols @@ -0,0 +1,13 @@ +=== /a/b/node_modules/foo.d.ts === + +export declare let x: number +>x : Symbol(x, Decl(foo.d.ts, 1, 18)) + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(app.ts, 0, 8)) + +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(lib.ts, 0, 8)) + diff --git a/tests/baselines/reference/cachedModuleResolution1.trace.json b/tests/baselines/reference/cachedModuleResolution1.trace.json new file mode 100644 index 0000000000000..dbb0e6068bee8 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution1.trace.json @@ -0,0 +1,46 @@ +[ + "======== Resolving module 'foo' from '/a/b/c/d/e/app.ts'. ========", + "Explicitly specified module resolution kind: 'NodeJs'.", + "Loading module 'foo' from 'node_modules' folder.", + "File '/a/b/c/d/e/node_modules/foo.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/d/e/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/d/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/c/node_modules/foo.ts' does not exist.", + "File '/a/b/c/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/node_modules/foo.ts' does not exist.", + "File '/a/b/node_modules/foo.tsx' does not exist.", + "File '/a/b/node_modules/foo.d.ts' exist - use it as a name resolution result.", + "Resolving real path for '/a/b/node_modules/foo.d.ts', result '/a/b/node_modules/foo.d.ts'", + "======== Module name 'foo' was successfully resolved to '/a/b/node_modules/foo.d.ts'. ========", + "======== Resolving module 'foo' from '/a/b/c/lib.ts'. ========", + "Explicitly specified module resolution kind: 'NodeJs'.", + "Loading module 'foo' from 'node_modules' folder.", + "Resolution for module 'foo' was found in cache", + "Resolving real path for '/a/b/node_modules/foo.d.ts', result '/a/b/node_modules/foo.d.ts'", + "======== Module name 'foo' was successfully resolved to '/a/b/node_modules/foo.d.ts'. ========" +] \ No newline at end of file diff --git a/tests/baselines/reference/cachedModuleResolution1.types b/tests/baselines/reference/cachedModuleResolution1.types new file mode 100644 index 0000000000000..c041e8cc340eb --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution1.types @@ -0,0 +1,13 @@ +=== /a/b/node_modules/foo.d.ts === + +export declare let x: number +>x : number + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : number + +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : number + diff --git a/tests/baselines/reference/cachedModuleResolution2.js b/tests/baselines/reference/cachedModuleResolution2.js new file mode 100644 index 0000000000000..7c84a92abaf5d --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution2.js @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/cachedModuleResolution2.ts] //// + +//// [foo.d.ts] + +export declare let x: number + +//// [lib.ts] +import {x} from "foo"; + +//// [app.ts] +import {x} from "foo"; + + +//// [lib.js] +"use strict"; +//// [app.js] +"use strict"; diff --git a/tests/baselines/reference/cachedModuleResolution2.symbols b/tests/baselines/reference/cachedModuleResolution2.symbols new file mode 100644 index 0000000000000..c8356eadb1193 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution2.symbols @@ -0,0 +1,13 @@ +=== /a/b/node_modules/foo.d.ts === + +export declare let x: number +>x : Symbol(x, Decl(foo.d.ts, 1, 18)) + +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(lib.ts, 0, 8)) + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(app.ts, 0, 8)) + diff --git a/tests/baselines/reference/cachedModuleResolution2.trace.json b/tests/baselines/reference/cachedModuleResolution2.trace.json new file mode 100644 index 0000000000000..1d4b40bbc081d --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution2.trace.json @@ -0,0 +1,46 @@ +[ + "======== Resolving module 'foo' from '/a/b/c/lib.ts'. ========", + "Explicitly specified module resolution kind: 'NodeJs'.", + "Loading module 'foo' from 'node_modules' folder.", + "File '/a/b/c/node_modules/foo.ts' does not exist.", + "File '/a/b/c/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/node_modules/foo.ts' does not exist.", + "File '/a/b/node_modules/foo.tsx' does not exist.", + "File '/a/b/node_modules/foo.d.ts' exist - use it as a name resolution result.", + "Resolving real path for '/a/b/node_modules/foo.d.ts', result '/a/b/node_modules/foo.d.ts'", + "======== Module name 'foo' was successfully resolved to '/a/b/node_modules/foo.d.ts'. ========", + "======== Resolving module 'foo' from '/a/b/c/d/e/app.ts'. ========", + "Explicitly specified module resolution kind: 'NodeJs'.", + "Loading module 'foo' from 'node_modules' folder.", + "File '/a/b/c/d/e/node_modules/foo.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/d/e/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/d/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo/index.d.ts' does not exist.", + "Resolution for module 'foo' was found in cache", + "Resolving real path for '/a/b/node_modules/foo.d.ts', result '/a/b/node_modules/foo.d.ts'", + "======== Module name 'foo' was successfully resolved to '/a/b/node_modules/foo.d.ts'. ========" +] \ No newline at end of file diff --git a/tests/baselines/reference/cachedModuleResolution2.types b/tests/baselines/reference/cachedModuleResolution2.types new file mode 100644 index 0000000000000..c5069e681c4d7 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution2.types @@ -0,0 +1,13 @@ +=== /a/b/node_modules/foo.d.ts === + +export declare let x: number +>x : number + +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : number + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : number + diff --git a/tests/baselines/reference/cachedModuleResolution3.js b/tests/baselines/reference/cachedModuleResolution3.js new file mode 100644 index 0000000000000..032c1afee0e89 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution3.js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/cachedModuleResolution3.ts] //// + +//// [foo.d.ts] + +export declare let x: number + +//// [app.ts] +import {x} from "foo"; + +//// [lib.ts] +import {x} from "foo"; + +//// [app.js] +"use strict"; +//// [lib.js] +"use strict"; diff --git a/tests/baselines/reference/cachedModuleResolution3.symbols b/tests/baselines/reference/cachedModuleResolution3.symbols new file mode 100644 index 0000000000000..799ac6d8d8438 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution3.symbols @@ -0,0 +1,13 @@ +=== /a/b/foo.d.ts === + +export declare let x: number +>x : Symbol(x, Decl(foo.d.ts, 1, 18)) + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(app.ts, 0, 8)) + +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(lib.ts, 0, 8)) + diff --git a/tests/baselines/reference/cachedModuleResolution3.trace.json b/tests/baselines/reference/cachedModuleResolution3.trace.json new file mode 100644 index 0000000000000..2dbaea53f47ac --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution3.trace.json @@ -0,0 +1,21 @@ +[ + "======== Resolving module 'foo' from '/a/b/c/d/e/app.ts'. ========", + "Explicitly specified module resolution kind: 'Classic'.", + "File '/a/b/c/d/e/foo.ts' does not exist.", + "File '/a/b/c/d/e/foo.tsx' does not exist.", + "File '/a/b/c/d/e/foo.d.ts' does not exist.", + "File '/a/b/c/d/foo.ts' does not exist.", + "File '/a/b/c/d/foo.tsx' does not exist.", + "File '/a/b/c/d/foo.d.ts' does not exist.", + "File '/a/b/c/foo.ts' does not exist.", + "File '/a/b/c/foo.tsx' does not exist.", + "File '/a/b/c/foo.d.ts' does not exist.", + "File '/a/b/foo.ts' does not exist.", + "File '/a/b/foo.tsx' does not exist.", + "File '/a/b/foo.d.ts' exist - use it as a name resolution result.", + "======== Module name 'foo' was successfully resolved to '/a/b/foo.d.ts'. ========", + "======== Resolving module 'foo' from '/a/b/c/lib.ts'. ========", + "Explicitly specified module resolution kind: 'Classic'.", + "Resolution for module 'foo' was found in cache", + "======== Module name 'foo' was successfully resolved to '/a/b/foo.d.ts'. ========" +] \ No newline at end of file diff --git a/tests/baselines/reference/cachedModuleResolution3.types b/tests/baselines/reference/cachedModuleResolution3.types new file mode 100644 index 0000000000000..f87abf1519eb4 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution3.types @@ -0,0 +1,13 @@ +=== /a/b/foo.d.ts === + +export declare let x: number +>x : number + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : number + +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : number + diff --git a/tests/baselines/reference/cachedModuleResolution4.js b/tests/baselines/reference/cachedModuleResolution4.js new file mode 100644 index 0000000000000..6089de9706bd6 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution4.js @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/cachedModuleResolution4.ts] //// + +//// [foo.d.ts] + +export declare let x: number + +//// [lib.ts] +import {x} from "foo"; + +//// [app.ts] +import {x} from "foo"; + + +//// [lib.js] +"use strict"; +//// [app.js] +"use strict"; diff --git a/tests/baselines/reference/cachedModuleResolution4.symbols b/tests/baselines/reference/cachedModuleResolution4.symbols new file mode 100644 index 0000000000000..a30e6bf74e543 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution4.symbols @@ -0,0 +1,13 @@ +=== /a/b/foo.d.ts === + +export declare let x: number +>x : Symbol(x, Decl(foo.d.ts, 1, 18)) + +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(lib.ts, 0, 8)) + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(app.ts, 0, 8)) + diff --git a/tests/baselines/reference/cachedModuleResolution4.trace.json b/tests/baselines/reference/cachedModuleResolution4.trace.json new file mode 100644 index 0000000000000..7249d948e1c7c --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution4.trace.json @@ -0,0 +1,21 @@ +[ + "======== Resolving module 'foo' from '/a/b/c/lib.ts'. ========", + "Explicitly specified module resolution kind: 'Classic'.", + "File '/a/b/c/foo.ts' does not exist.", + "File '/a/b/c/foo.tsx' does not exist.", + "File '/a/b/c/foo.d.ts' does not exist.", + "File '/a/b/foo.ts' does not exist.", + "File '/a/b/foo.tsx' does not exist.", + "File '/a/b/foo.d.ts' exist - use it as a name resolution result.", + "======== Module name 'foo' was successfully resolved to '/a/b/foo.d.ts'. ========", + "======== Resolving module 'foo' from '/a/b/c/d/e/app.ts'. ========", + "Explicitly specified module resolution kind: 'Classic'.", + "File '/a/b/c/d/e/foo.ts' does not exist.", + "File '/a/b/c/d/e/foo.tsx' does not exist.", + "File '/a/b/c/d/e/foo.d.ts' does not exist.", + "File '/a/b/c/d/foo.ts' does not exist.", + "File '/a/b/c/d/foo.tsx' does not exist.", + "File '/a/b/c/d/foo.d.ts' does not exist.", + "Resolution for module 'foo' was found in cache", + "======== Module name 'foo' was successfully resolved to '/a/b/foo.d.ts'. ========" +] \ No newline at end of file diff --git a/tests/baselines/reference/cachedModuleResolution4.types b/tests/baselines/reference/cachedModuleResolution4.types new file mode 100644 index 0000000000000..3689e57ca6d0e --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution4.types @@ -0,0 +1,13 @@ +=== /a/b/foo.d.ts === + +export declare let x: number +>x : number + +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : number + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : number + diff --git a/tests/baselines/reference/cachedModuleResolution5.js b/tests/baselines/reference/cachedModuleResolution5.js new file mode 100644 index 0000000000000..33561e8eae268 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution5.js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/cachedModuleResolution5.ts] //// + +//// [foo.d.ts] + +export declare let x: number + +//// [app.ts] +import {x} from "foo"; + +//// [lib.ts] +import {x} from "foo"; + +//// [app.js] +"use strict"; +//// [lib.js] +"use strict"; diff --git a/tests/baselines/reference/cachedModuleResolution5.symbols b/tests/baselines/reference/cachedModuleResolution5.symbols new file mode 100644 index 0000000000000..eb72f0c7a27dc --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution5.symbols @@ -0,0 +1,13 @@ +=== /a/b/node_modules/foo.d.ts === + +export declare let x: number +>x : Symbol(x, Decl(foo.d.ts, 1, 18)) + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(app.ts, 0, 8)) + +=== /a/b/lib.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(lib.ts, 0, 8)) + diff --git a/tests/baselines/reference/cachedModuleResolution5.trace.json b/tests/baselines/reference/cachedModuleResolution5.trace.json new file mode 100644 index 0000000000000..d263465ff122d --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution5.trace.json @@ -0,0 +1,46 @@ +[ + "======== Resolving module 'foo' from '/a/b/c/d/e/app.ts'. ========", + "Explicitly specified module resolution kind: 'NodeJs'.", + "Loading module 'foo' from 'node_modules' folder.", + "File '/a/b/c/d/e/node_modules/foo.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/d/e/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/d/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/c/node_modules/foo.ts' does not exist.", + "File '/a/b/c/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/node_modules/foo.ts' does not exist.", + "File '/a/b/node_modules/foo.tsx' does not exist.", + "File '/a/b/node_modules/foo.d.ts' exist - use it as a name resolution result.", + "Resolving real path for '/a/b/node_modules/foo.d.ts', result '/a/b/node_modules/foo.d.ts'", + "======== Module name 'foo' was successfully resolved to '/a/b/node_modules/foo.d.ts'. ========", + "======== Resolving module 'foo' from '/a/b/lib.ts'. ========", + "Explicitly specified module resolution kind: 'NodeJs'.", + "Loading module 'foo' from 'node_modules' folder.", + "Resolution for module 'foo' was found in cache", + "Resolving real path for '/a/b/node_modules/foo.d.ts', result '/a/b/node_modules/foo.d.ts'", + "======== Module name 'foo' was successfully resolved to '/a/b/node_modules/foo.d.ts'. ========" +] \ No newline at end of file diff --git a/tests/baselines/reference/cachedModuleResolution5.types b/tests/baselines/reference/cachedModuleResolution5.types new file mode 100644 index 0000000000000..ad2640402f7c6 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution5.types @@ -0,0 +1,13 @@ +=== /a/b/node_modules/foo.d.ts === + +export declare let x: number +>x : number + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : number + +=== /a/b/lib.ts === +import {x} from "foo"; +>x : number + diff --git a/tests/baselines/reference/cachedModuleResolution6.errors.txt b/tests/baselines/reference/cachedModuleResolution6.errors.txt new file mode 100644 index 0000000000000..b272ff29b9d38 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution6.errors.txt @@ -0,0 +1,14 @@ +/a/b/c/d/e/app.ts(2,17): error TS2307: Cannot find module 'foo'. +/a/b/c/lib.ts(1,17): error TS2307: Cannot find module 'foo'. + + +==== /a/b/c/d/e/app.ts (1 errors) ==== + + import {x} from "foo"; + ~~~~~ +!!! error TS2307: Cannot find module 'foo'. + +==== /a/b/c/lib.ts (1 errors) ==== + import {x} from "foo"; + ~~~~~ +!!! error TS2307: Cannot find module 'foo'. \ No newline at end of file diff --git a/tests/baselines/reference/cachedModuleResolution6.js b/tests/baselines/reference/cachedModuleResolution6.js new file mode 100644 index 0000000000000..f21f491a921de --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution6.js @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/cachedModuleResolution6.ts] //// + +//// [app.ts] + +import {x} from "foo"; + +//// [lib.ts] +import {x} from "foo"; + +//// [app.js] +"use strict"; +//// [lib.js] +"use strict"; diff --git a/tests/baselines/reference/cachedModuleResolution6.trace.json b/tests/baselines/reference/cachedModuleResolution6.trace.json new file mode 100644 index 0000000000000..02d52befc942b --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution6.trace.json @@ -0,0 +1,102 @@ +[ + "======== Resolving module 'foo' from '/a/b/c/d/e/app.ts'. ========", + "Explicitly specified module resolution kind: 'NodeJs'.", + "Loading module 'foo' from 'node_modules' folder.", + "File '/a/b/c/d/e/node_modules/foo.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/d/e/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/d/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/c/node_modules/foo.ts' does not exist.", + "File '/a/b/c/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/node_modules/foo.ts' does not exist.", + "File '/a/b/node_modules/foo.tsx' does not exist.", + "File '/a/b/node_modules/foo.d.ts' does not exist.", + "File '/a/b/node_modules/foo/package.json' does not exist.", + "File '/a/b/node_modules/foo/index.ts' does not exist.", + "File '/a/b/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/node_modules/foo.ts' does not exist.", + "File '/a/node_modules/foo.tsx' does not exist.", + "File '/a/node_modules/foo.d.ts' does not exist.", + "File '/a/node_modules/foo/package.json' does not exist.", + "File '/a/node_modules/foo/index.ts' does not exist.", + "File '/a/node_modules/foo/index.tsx' does not exist.", + "File '/a/node_modules/foo/index.d.ts' does not exist.", + "File '/a/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/node_modules/@types/foo/package.json' does not exist.", + "File '/a/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/node_modules/foo.ts' does not exist.", + "File '/node_modules/foo.tsx' does not exist.", + "File '/node_modules/foo.d.ts' does not exist.", + "File '/node_modules/foo/package.json' does not exist.", + "File '/node_modules/foo/index.ts' does not exist.", + "File '/node_modules/foo/index.tsx' does not exist.", + "File '/node_modules/foo/index.d.ts' does not exist.", + "File '/node_modules/@types/foo.d.ts' does not exist.", + "File '/node_modules/@types/foo/package.json' does not exist.", + "File '/node_modules/@types/foo/index.d.ts' does not exist.", + "Loading module 'foo' from 'node_modules' folder.", + "File '/a/b/c/d/e/node_modules/foo.js' does not exist.", + "File '/a/b/c/d/e/node_modules/foo.jsx' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.js' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.jsx' does not exist.", + "File '/a/b/c/d/node_modules/foo.js' does not exist.", + "File '/a/b/c/d/node_modules/foo.jsx' does not exist.", + "File '/a/b/c/d/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.js' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.jsx' does not exist.", + "File '/a/b/c/node_modules/foo.js' does not exist.", + "File '/a/b/c/node_modules/foo.jsx' does not exist.", + "File '/a/b/c/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/foo/index.js' does not exist.", + "File '/a/b/c/node_modules/foo/index.jsx' does not exist.", + "File '/a/b/node_modules/foo.js' does not exist.", + "File '/a/b/node_modules/foo.jsx' does not exist.", + "File '/a/b/node_modules/foo/package.json' does not exist.", + "File '/a/b/node_modules/foo/index.js' does not exist.", + "File '/a/b/node_modules/foo/index.jsx' does not exist.", + "File '/a/node_modules/foo.js' does not exist.", + "File '/a/node_modules/foo.jsx' does not exist.", + "File '/a/node_modules/foo/package.json' does not exist.", + "File '/a/node_modules/foo/index.js' does not exist.", + "File '/a/node_modules/foo/index.jsx' does not exist.", + "File '/node_modules/foo.js' does not exist.", + "File '/node_modules/foo.jsx' does not exist.", + "File '/node_modules/foo/package.json' does not exist.", + "File '/node_modules/foo/index.js' does not exist.", + "File '/node_modules/foo/index.jsx' does not exist.", + "======== Module name 'foo' was not resolved. ========", + "======== Resolving module 'foo' from '/a/b/c/lib.ts'. ========", + "Explicitly specified module resolution kind: 'NodeJs'.", + "Loading module 'foo' from 'node_modules' folder.", + "Resolution for module 'foo' was found in cache", + "======== Module name 'foo' was not resolved. ========" +] \ No newline at end of file diff --git a/tests/baselines/reference/cachedModuleResolution7.errors.txt b/tests/baselines/reference/cachedModuleResolution7.errors.txt new file mode 100644 index 0000000000000..670c4a665a698 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution7.errors.txt @@ -0,0 +1,15 @@ +/a/b/c/d/e/app.ts(1,17): error TS2307: Cannot find module 'foo'. +/a/b/c/lib.ts(2,17): error TS2307: Cannot find module 'foo'. + + +==== /a/b/c/lib.ts (1 errors) ==== + + import {x} from "foo"; + ~~~~~ +!!! error TS2307: Cannot find module 'foo'. + +==== /a/b/c/d/e/app.ts (1 errors) ==== + import {x} from "foo"; + ~~~~~ +!!! error TS2307: Cannot find module 'foo'. + \ No newline at end of file diff --git a/tests/baselines/reference/cachedModuleResolution7.js b/tests/baselines/reference/cachedModuleResolution7.js new file mode 100644 index 0000000000000..8b86dcd55af4c --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution7.js @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/cachedModuleResolution7.ts] //// + +//// [lib.ts] + +import {x} from "foo"; + +//// [app.ts] +import {x} from "foo"; + + +//// [lib.js] +"use strict"; +//// [app.js] +"use strict"; diff --git a/tests/baselines/reference/cachedModuleResolution7.trace.json b/tests/baselines/reference/cachedModuleResolution7.trace.json new file mode 100644 index 0000000000000..ce5bf08861d13 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution7.trace.json @@ -0,0 +1,92 @@ +[ + "======== Resolving module 'foo' from '/a/b/c/lib.ts'. ========", + "Explicitly specified module resolution kind: 'NodeJs'.", + "Loading module 'foo' from 'node_modules' folder.", + "File '/a/b/c/node_modules/foo.ts' does not exist.", + "File '/a/b/c/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/node_modules/foo.ts' does not exist.", + "File '/a/b/node_modules/foo.tsx' does not exist.", + "File '/a/b/node_modules/foo.d.ts' does not exist.", + "File '/a/b/node_modules/foo/package.json' does not exist.", + "File '/a/b/node_modules/foo/index.ts' does not exist.", + "File '/a/b/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/node_modules/foo.ts' does not exist.", + "File '/a/node_modules/foo.tsx' does not exist.", + "File '/a/node_modules/foo.d.ts' does not exist.", + "File '/a/node_modules/foo/package.json' does not exist.", + "File '/a/node_modules/foo/index.ts' does not exist.", + "File '/a/node_modules/foo/index.tsx' does not exist.", + "File '/a/node_modules/foo/index.d.ts' does not exist.", + "File '/a/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/node_modules/@types/foo/package.json' does not exist.", + "File '/a/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/node_modules/foo.ts' does not exist.", + "File '/node_modules/foo.tsx' does not exist.", + "File '/node_modules/foo.d.ts' does not exist.", + "File '/node_modules/foo/package.json' does not exist.", + "File '/node_modules/foo/index.ts' does not exist.", + "File '/node_modules/foo/index.tsx' does not exist.", + "File '/node_modules/foo/index.d.ts' does not exist.", + "File '/node_modules/@types/foo.d.ts' does not exist.", + "File '/node_modules/@types/foo/package.json' does not exist.", + "File '/node_modules/@types/foo/index.d.ts' does not exist.", + "Loading module 'foo' from 'node_modules' folder.", + "File '/a/b/c/node_modules/foo.js' does not exist.", + "File '/a/b/c/node_modules/foo.jsx' does not exist.", + "File '/a/b/c/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/foo/index.js' does not exist.", + "File '/a/b/c/node_modules/foo/index.jsx' does not exist.", + "File '/a/b/node_modules/foo.js' does not exist.", + "File '/a/b/node_modules/foo.jsx' does not exist.", + "File '/a/b/node_modules/foo/package.json' does not exist.", + "File '/a/b/node_modules/foo/index.js' does not exist.", + "File '/a/b/node_modules/foo/index.jsx' does not exist.", + "File '/a/node_modules/foo.js' does not exist.", + "File '/a/node_modules/foo.jsx' does not exist.", + "File '/a/node_modules/foo/package.json' does not exist.", + "File '/a/node_modules/foo/index.js' does not exist.", + "File '/a/node_modules/foo/index.jsx' does not exist.", + "File '/node_modules/foo.js' does not exist.", + "File '/node_modules/foo.jsx' does not exist.", + "File '/node_modules/foo/package.json' does not exist.", + "File '/node_modules/foo/index.js' does not exist.", + "File '/node_modules/foo/index.jsx' does not exist.", + "======== Module name 'foo' was not resolved. ========", + "======== Resolving module 'foo' from '/a/b/c/d/e/app.ts'. ========", + "Explicitly specified module resolution kind: 'NodeJs'.", + "Loading module 'foo' from 'node_modules' folder.", + "File '/a/b/c/d/e/node_modules/foo.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/d/e/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/d/e/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo.tsx' does not exist.", + "File '/a/b/c/d/node_modules/foo.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo/package.json' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.ts' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.tsx' does not exist.", + "File '/a/b/c/d/node_modules/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo/index.d.ts' does not exist.", + "Resolution for module 'foo' was found in cache", + "======== Module name 'foo' was not resolved. ========" +] \ No newline at end of file diff --git a/tests/baselines/reference/cachedModuleResolution8.errors.txt b/tests/baselines/reference/cachedModuleResolution8.errors.txt new file mode 100644 index 0000000000000..b272ff29b9d38 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution8.errors.txt @@ -0,0 +1,14 @@ +/a/b/c/d/e/app.ts(2,17): error TS2307: Cannot find module 'foo'. +/a/b/c/lib.ts(1,17): error TS2307: Cannot find module 'foo'. + + +==== /a/b/c/d/e/app.ts (1 errors) ==== + + import {x} from "foo"; + ~~~~~ +!!! error TS2307: Cannot find module 'foo'. + +==== /a/b/c/lib.ts (1 errors) ==== + import {x} from "foo"; + ~~~~~ +!!! error TS2307: Cannot find module 'foo'. \ No newline at end of file diff --git a/tests/baselines/reference/cachedModuleResolution8.js b/tests/baselines/reference/cachedModuleResolution8.js new file mode 100644 index 0000000000000..1c00b171f21d2 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution8.js @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/cachedModuleResolution8.ts] //// + +//// [app.ts] + +import {x} from "foo"; + +//// [lib.ts] +import {x} from "foo"; + +//// [app.js] +"use strict"; +//// [lib.js] +"use strict"; diff --git a/tests/baselines/reference/cachedModuleResolution8.trace.json b/tests/baselines/reference/cachedModuleResolution8.trace.json new file mode 100644 index 0000000000000..f833f56d81945 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution8.trace.json @@ -0,0 +1,57 @@ +[ + "======== Resolving module 'foo' from '/a/b/c/d/e/app.ts'. ========", + "Explicitly specified module resolution kind: 'Classic'.", + "File '/a/b/c/d/e/foo.ts' does not exist.", + "File '/a/b/c/d/e/foo.tsx' does not exist.", + "File '/a/b/c/d/e/foo.d.ts' does not exist.", + "File '/a/b/c/d/foo.ts' does not exist.", + "File '/a/b/c/d/foo.tsx' does not exist.", + "File '/a/b/c/d/foo.d.ts' does not exist.", + "File '/a/b/c/foo.ts' does not exist.", + "File '/a/b/c/foo.tsx' does not exist.", + "File '/a/b/c/foo.d.ts' does not exist.", + "File '/a/b/foo.ts' does not exist.", + "File '/a/b/foo.tsx' does not exist.", + "File '/a/b/foo.d.ts' does not exist.", + "File '/a/foo.ts' does not exist.", + "File '/a/foo.tsx' does not exist.", + "File '/a/foo.d.ts' does not exist.", + "File '/foo.ts' does not exist.", + "File '/foo.tsx' does not exist.", + "File '/foo.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/d/e/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/d/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/node_modules/@types/foo/package.json' does not exist.", + "File '/a/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/node_modules/@types/foo.d.ts' does not exist.", + "File '/node_modules/@types/foo/package.json' does not exist.", + "File '/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/c/d/e/foo.js' does not exist.", + "File '/a/b/c/d/e/foo.jsx' does not exist.", + "File '/a/b/c/d/foo.js' does not exist.", + "File '/a/b/c/d/foo.jsx' does not exist.", + "File '/a/b/c/foo.js' does not exist.", + "File '/a/b/c/foo.jsx' does not exist.", + "File '/a/b/foo.js' does not exist.", + "File '/a/b/foo.jsx' does not exist.", + "File '/a/foo.js' does not exist.", + "File '/a/foo.jsx' does not exist.", + "File '/foo.js' does not exist.", + "File '/foo.jsx' does not exist.", + "======== Module name 'foo' was not resolved. ========", + "======== Resolving module 'foo' from '/a/b/c/lib.ts'. ========", + "Explicitly specified module resolution kind: 'Classic'.", + "Resolution for module 'foo' was found in cache", + "======== Module name 'foo' was not resolved. ========" +] \ No newline at end of file diff --git a/tests/baselines/reference/cachedModuleResolution9.errors.txt b/tests/baselines/reference/cachedModuleResolution9.errors.txt new file mode 100644 index 0000000000000..aeec41f0048f8 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution9.errors.txt @@ -0,0 +1,16 @@ +/a/b/c/d/e/app.ts(1,17): error TS2307: Cannot find module 'foo'. +/a/b/c/lib.ts(2,17): error TS2307: Cannot find module 'foo'. + + +==== /a/b/c/lib.ts (1 errors) ==== + + import {x} from "foo"; + ~~~~~ +!!! error TS2307: Cannot find module 'foo'. + + +==== /a/b/c/d/e/app.ts (1 errors) ==== + import {x} from "foo"; + ~~~~~ +!!! error TS2307: Cannot find module 'foo'. + \ No newline at end of file diff --git a/tests/baselines/reference/cachedModuleResolution9.js b/tests/baselines/reference/cachedModuleResolution9.js new file mode 100644 index 0000000000000..32f8848736ce1 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution9.js @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/cachedModuleResolution9.ts] //// + +//// [lib.ts] + +import {x} from "foo"; + + +//// [app.ts] +import {x} from "foo"; + + +//// [lib.js] +"use strict"; +//// [app.js] +"use strict"; diff --git a/tests/baselines/reference/cachedModuleResolution9.trace.json b/tests/baselines/reference/cachedModuleResolution9.trace.json new file mode 100644 index 0000000000000..10a79576bfcde --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution9.trace.json @@ -0,0 +1,47 @@ +[ + "======== Resolving module 'foo' from '/a/b/c/lib.ts'. ========", + "Explicitly specified module resolution kind: 'Classic'.", + "File '/a/b/c/foo.ts' does not exist.", + "File '/a/b/c/foo.tsx' does not exist.", + "File '/a/b/c/foo.d.ts' does not exist.", + "File '/a/b/foo.ts' does not exist.", + "File '/a/b/foo.tsx' does not exist.", + "File '/a/b/foo.d.ts' does not exist.", + "File '/a/foo.ts' does not exist.", + "File '/a/foo.tsx' does not exist.", + "File '/a/foo.d.ts' does not exist.", + "File '/foo.ts' does not exist.", + "File '/foo.tsx' does not exist.", + "File '/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/c/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/c/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/b/node_modules/@types/foo/package.json' does not exist.", + "File '/a/b/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/node_modules/@types/foo.d.ts' does not exist.", + "File '/a/node_modules/@types/foo/package.json' does not exist.", + "File '/a/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/node_modules/@types/foo.d.ts' does not exist.", + "File '/node_modules/@types/foo/package.json' does not exist.", + "File '/node_modules/@types/foo/index.d.ts' does not exist.", + "File '/a/b/c/foo.js' does not exist.", + "File '/a/b/c/foo.jsx' does not exist.", + "File '/a/b/foo.js' does not exist.", + "File '/a/b/foo.jsx' does not exist.", + "File '/a/foo.js' does not exist.", + "File '/a/foo.jsx' does not exist.", + "File '/foo.js' does not exist.", + "File '/foo.jsx' does not exist.", + "======== Module name 'foo' was not resolved. ========", + "======== Resolving module 'foo' from '/a/b/c/d/e/app.ts'. ========", + "Explicitly specified module resolution kind: 'Classic'.", + "File '/a/b/c/d/e/foo.ts' does not exist.", + "File '/a/b/c/d/e/foo.tsx' does not exist.", + "File '/a/b/c/d/e/foo.d.ts' does not exist.", + "File '/a/b/c/d/foo.ts' does not exist.", + "File '/a/b/c/d/foo.tsx' does not exist.", + "File '/a/b/c/d/foo.d.ts' does not exist.", + "Resolution for module 'foo' was found in cache", + "======== Module name 'foo' was not resolved. ========" +] \ No newline at end of file diff --git a/tests/cases/compiler/cachedModuleResolution1.ts b/tests/cases/compiler/cachedModuleResolution1.ts new file mode 100644 index 0000000000000..3ef09ea0ea512 --- /dev/null +++ b/tests/cases/compiler/cachedModuleResolution1.ts @@ -0,0 +1,11 @@ +// @moduleResolution: node +// @traceResolution: true + +// @filename: /a/b/node_modules/foo.d.ts +export declare let x: number + +// @filename: /a/b/c/d/e/app.ts +import {x} from "foo"; + +// @filename: /a/b/c/lib.ts +import {x} from "foo"; \ No newline at end of file diff --git a/tests/cases/compiler/cachedModuleResolution2.ts b/tests/cases/compiler/cachedModuleResolution2.ts new file mode 100644 index 0000000000000..38aaf4e609df3 --- /dev/null +++ b/tests/cases/compiler/cachedModuleResolution2.ts @@ -0,0 +1,11 @@ +// @moduleResolution: node +// @traceResolution: true + +// @filename: /a/b/node_modules/foo.d.ts +export declare let x: number + +// @filename: /a/b/c/lib.ts +import {x} from "foo"; + +// @filename: /a/b/c/d/e/app.ts +import {x} from "foo"; diff --git a/tests/cases/compiler/cachedModuleResolution3.ts b/tests/cases/compiler/cachedModuleResolution3.ts new file mode 100644 index 0000000000000..e1e7aebbe861f --- /dev/null +++ b/tests/cases/compiler/cachedModuleResolution3.ts @@ -0,0 +1,11 @@ +// @moduleResolution: classic +// @traceResolution: true + +// @filename: /a/b/foo.d.ts +export declare let x: number + +// @filename: /a/b/c/d/e/app.ts +import {x} from "foo"; + +// @filename: /a/b/c/lib.ts +import {x} from "foo"; \ No newline at end of file diff --git a/tests/cases/compiler/cachedModuleResolution4.ts b/tests/cases/compiler/cachedModuleResolution4.ts new file mode 100644 index 0000000000000..98cdd14189a55 --- /dev/null +++ b/tests/cases/compiler/cachedModuleResolution4.ts @@ -0,0 +1,11 @@ +// @moduleResolution: classic +// @traceResolution: true + +// @filename: /a/b/foo.d.ts +export declare let x: number + +// @filename: /a/b/c/lib.ts +import {x} from "foo"; + +// @filename: /a/b/c/d/e/app.ts +import {x} from "foo"; diff --git a/tests/cases/compiler/cachedModuleResolution5.ts b/tests/cases/compiler/cachedModuleResolution5.ts new file mode 100644 index 0000000000000..e37b14fc1a0b7 --- /dev/null +++ b/tests/cases/compiler/cachedModuleResolution5.ts @@ -0,0 +1,11 @@ +// @moduleResolution: node +// @traceResolution: true + +// @filename: /a/b/node_modules/foo.d.ts +export declare let x: number + +// @filename: /a/b/c/d/e/app.ts +import {x} from "foo"; + +// @filename: /a/b/lib.ts +import {x} from "foo"; \ No newline at end of file diff --git a/tests/cases/compiler/cachedModuleResolution6.ts b/tests/cases/compiler/cachedModuleResolution6.ts new file mode 100644 index 0000000000000..2c412e361c6c5 --- /dev/null +++ b/tests/cases/compiler/cachedModuleResolution6.ts @@ -0,0 +1,8 @@ +// @moduleResolution: node +// @traceResolution: true + +// @filename: /a/b/c/d/e/app.ts +import {x} from "foo"; + +// @filename: /a/b/c/lib.ts +import {x} from "foo"; \ No newline at end of file diff --git a/tests/cases/compiler/cachedModuleResolution7.ts b/tests/cases/compiler/cachedModuleResolution7.ts new file mode 100644 index 0000000000000..d297e2a8ecd63 --- /dev/null +++ b/tests/cases/compiler/cachedModuleResolution7.ts @@ -0,0 +1,8 @@ +// @moduleResolution: node +// @traceResolution: true + +// @filename: /a/b/c/lib.ts +import {x} from "foo"; + +// @filename: /a/b/c/d/e/app.ts +import {x} from "foo"; diff --git a/tests/cases/compiler/cachedModuleResolution8.ts b/tests/cases/compiler/cachedModuleResolution8.ts new file mode 100644 index 0000000000000..52c91be7753b5 --- /dev/null +++ b/tests/cases/compiler/cachedModuleResolution8.ts @@ -0,0 +1,8 @@ +// @moduleResolution: classic +// @traceResolution: true + +// @filename: /a/b/c/d/e/app.ts +import {x} from "foo"; + +// @filename: /a/b/c/lib.ts +import {x} from "foo"; \ No newline at end of file diff --git a/tests/cases/compiler/cachedModuleResolution9.ts b/tests/cases/compiler/cachedModuleResolution9.ts new file mode 100644 index 0000000000000..26d71fa86ffa8 --- /dev/null +++ b/tests/cases/compiler/cachedModuleResolution9.ts @@ -0,0 +1,9 @@ +// @moduleResolution: classic +// @traceResolution: true + +// @filename: /a/b/c/lib.ts +import {x} from "foo"; + + +// @filename: /a/b/c/d/e/app.ts +import {x} from "foo"; From 14cce292506b29aa88d26c0ad9ca94d7fb32e6d8 Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Wed, 21 Dec 2016 09:45:33 -0800 Subject: [PATCH 19/24] Do not report error on unused removed property from object spread Fixes #13076 --- src/compiler/checker.ts | 2 +- .../reference/unusedLocalsAndObjectSpread2.errors.txt | 8 +------- 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 36b952dd046fa..d25c010ccfb74 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -16891,7 +16891,7 @@ namespace ts { if (!local.isReferenced && !local.exportSymbol) { for (const declaration of local.declarations) { if (!isAmbientModule(declaration)) { - error(declaration.name, Diagnostics._0_is_declared_but_never_used, local.name); + errorUnusedLocal(declaration.name, local.name); } } } diff --git a/tests/baselines/reference/unusedLocalsAndObjectSpread2.errors.txt b/tests/baselines/reference/unusedLocalsAndObjectSpread2.errors.txt index 0908f5ce3b9c0..2d1c36d3cbfda 100644 --- a/tests/baselines/reference/unusedLocalsAndObjectSpread2.errors.txt +++ b/tests/baselines/reference/unusedLocalsAndObjectSpread2.errors.txt @@ -1,20 +1,14 @@ -tests/cases/compiler/unusedLocalsAndObjectSpread2.ts(4,5): error TS6133: 'children' is declared but never used. -tests/cases/compiler/unusedLocalsAndObjectSpread2.ts(5,13): error TS6133: '_a' is declared but never used. tests/cases/compiler/unusedLocalsAndObjectSpread2.ts(6,6): error TS6133: 'rest' is declared but never used. tests/cases/compiler/unusedLocalsAndObjectSpread2.ts(9,10): error TS6133: 'foo' is declared but never used. tests/cases/compiler/unusedLocalsAndObjectSpread2.ts(13,8): error TS6133: 'rest' is declared but never used. -==== tests/cases/compiler/unusedLocalsAndObjectSpread2.ts (5 errors) ==== +==== tests/cases/compiler/unusedLocalsAndObjectSpread2.ts (3 errors) ==== declare let props: any; const { children, // here! - ~~~~~~~~ -!!! error TS6133: 'children' is declared but never used. active: _a, // here! - ~~ -!!! error TS6133: '_a' is declared but never used. ...rest, ~~~~ !!! error TS6133: 'rest' is declared but never used. From 62426de220f7404508f7a0fd9f22f677d7cfcab2 Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Wed, 21 Dec 2016 12:11:47 -0800 Subject: [PATCH 20/24] Nit: Moving type aliases for serialized type nodes as per feedback --- src/compiler/transformers/ts.ts | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index ecd2e2dfcfd9d..f791025807a25 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -1555,12 +1555,15 @@ namespace ts { return false; } + type SerializedEntityNameAsExpression = Identifier | BinaryExpression | PropertyAccessExpression; + type SerializedTypeNode = SerializedEntityNameAsExpression | VoidExpression | ConditionalExpression; + /** * Serializes the type of a node for use with decorator type metadata. * * @param node The node that should have its type serialized. */ - function serializeTypeOfNode(node: Node): Expression { + function serializeTypeOfNode(node: Node): SerializedTypeNode { switch (node.kind) { case SyntaxKind.PropertyDeclaration: case SyntaxKind.Parameter: @@ -1582,7 +1585,7 @@ namespace ts { * * @param node The node that should have its parameter types serialized. */ - function serializeParameterTypesOfNode(node: Node, container: ClassLikeDeclaration): Expression { + function serializeParameterTypesOfNode(node: Node, container: ClassLikeDeclaration): ArrayLiteralExpression { const valueDeclaration = isClassLike(node) ? getFirstConstructorWithBody(node) @@ -1590,7 +1593,7 @@ namespace ts { ? node : undefined; - const expressions: Expression[] = []; + const expressions: SerializedTypeNode[] = []; if (valueDeclaration) { const parameters = getParametersOfDecoratedDeclaration(valueDeclaration, container); const numParameters = parameters.length; @@ -1626,7 +1629,7 @@ namespace ts { * * @param node The node that should have its return type serialized. */ - function serializeReturnTypeOfNode(node: Node): Expression { + function serializeReturnTypeOfNode(node: Node): SerializedTypeNode { if (isFunctionLike(node) && node.type) { return serializeTypeNode(node.type); } @@ -1637,8 +1640,6 @@ namespace ts { return createVoidZero(); } - type SerializedTypeNode = SerializedEntityNameAsExpression | VoidExpression | ConditionalExpression; - /** * Serializes a type node for use with decorator type metadata. * @@ -1826,7 +1827,6 @@ namespace ts { } } - type SerializedEntityNameAsExpression = Identifier | BinaryExpression | PropertyAccessExpression; /** * Serializes an entity name as an expression for decorator type metadata. * From 32c477a4486341b0023ac318ec45539d5a4df321 Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Wed, 21 Dec 2016 12:28:29 -0800 Subject: [PATCH 21/24] Test case for metadata type of class from a module --- .../reference/metadataOfClassFromModule.js | 44 +++++++++++++++++++ .../metadataOfClassFromModule.symbols | 22 ++++++++++ .../reference/metadataOfClassFromModule.types | 22 ++++++++++ .../compiler/metadataOfClassFromModule.ts | 14 ++++++ 4 files changed, 102 insertions(+) create mode 100644 tests/baselines/reference/metadataOfClassFromModule.js create mode 100644 tests/baselines/reference/metadataOfClassFromModule.symbols create mode 100644 tests/baselines/reference/metadataOfClassFromModule.types create mode 100644 tests/cases/compiler/metadataOfClassFromModule.ts diff --git a/tests/baselines/reference/metadataOfClassFromModule.js b/tests/baselines/reference/metadataOfClassFromModule.js new file mode 100644 index 0000000000000..8d9f97489f2cd --- /dev/null +++ b/tests/baselines/reference/metadataOfClassFromModule.js @@ -0,0 +1,44 @@ +//// [metadataOfClassFromModule.ts] +module MyModule { + + export function inject(target: any, key: string): void { } + + export class Leg { } + + export class Person { + @inject leftLeg: Leg; + } + +} + +//// [metadataOfClassFromModule.js] +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +var MyModule; +(function (MyModule) { + function inject(target, key) { } + MyModule.inject = inject; + var Leg = (function () { + function Leg() { + } + return Leg; + }()); + MyModule.Leg = Leg; + var Person = (function () { + function Person() { + } + return Person; + }()); + __decorate([ + inject, + __metadata("design:type", Object) + ], Person.prototype, "leftLeg", void 0); + MyModule.Person = Person; +})(MyModule || (MyModule = {})); diff --git a/tests/baselines/reference/metadataOfClassFromModule.symbols b/tests/baselines/reference/metadataOfClassFromModule.symbols new file mode 100644 index 0000000000000..f430677f0fa7e --- /dev/null +++ b/tests/baselines/reference/metadataOfClassFromModule.symbols @@ -0,0 +1,22 @@ +=== tests/cases/compiler/metadataOfClassFromModule.ts === +module MyModule { +>MyModule : Symbol(MyModule, Decl(metadataOfClassFromModule.ts, 0, 0)) + + export function inject(target: any, key: string): void { } +>inject : Symbol(inject, Decl(metadataOfClassFromModule.ts, 0, 17)) +>target : Symbol(target, Decl(metadataOfClassFromModule.ts, 2, 27)) +>key : Symbol(key, Decl(metadataOfClassFromModule.ts, 2, 39)) + + export class Leg { } +>Leg : Symbol(Leg, Decl(metadataOfClassFromModule.ts, 2, 62)) + + export class Person { +>Person : Symbol(Person, Decl(metadataOfClassFromModule.ts, 4, 24)) + + @inject leftLeg: Leg; +>inject : Symbol(inject, Decl(metadataOfClassFromModule.ts, 0, 17)) +>leftLeg : Symbol(Person.leftLeg, Decl(metadataOfClassFromModule.ts, 6, 25)) +>Leg : Symbol(Leg, Decl(metadataOfClassFromModule.ts, 2, 62)) + } + +} diff --git a/tests/baselines/reference/metadataOfClassFromModule.types b/tests/baselines/reference/metadataOfClassFromModule.types new file mode 100644 index 0000000000000..eeb24bf82aa76 --- /dev/null +++ b/tests/baselines/reference/metadataOfClassFromModule.types @@ -0,0 +1,22 @@ +=== tests/cases/compiler/metadataOfClassFromModule.ts === +module MyModule { +>MyModule : typeof MyModule + + export function inject(target: any, key: string): void { } +>inject : (target: any, key: string) => void +>target : any +>key : string + + export class Leg { } +>Leg : Leg + + export class Person { +>Person : Person + + @inject leftLeg: Leg; +>inject : (target: any, key: string) => void +>leftLeg : Leg +>Leg : Leg + } + +} diff --git a/tests/cases/compiler/metadataOfClassFromModule.ts b/tests/cases/compiler/metadataOfClassFromModule.ts new file mode 100644 index 0000000000000..aca356f22471a --- /dev/null +++ b/tests/cases/compiler/metadataOfClassFromModule.ts @@ -0,0 +1,14 @@ +// @experimentalDecorators: true +// @emitDecoratorMetadata: true +// @target: es5 +module MyModule { + + export function inject(target: any, key: string): void { } + + export class Leg { } + + export class Person { + @inject leftLeg: Leg; + } + +} \ No newline at end of file From 08e6b1bc4872374f13acf5d75c3c54643c6137b9 Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Wed, 21 Dec 2016 12:29:52 -0800 Subject: [PATCH 22/24] Update current scope when visiting namespace elements Fixes #13098 --- src/compiler/transformers/ts.ts | 2 +- tests/baselines/reference/metadataOfClassFromModule.js | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index f791025807a25..775f60355d8bc 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -2731,7 +2731,7 @@ namespace ts { let blockLocation: TextRange; const body = node.body; if (body.kind === SyntaxKind.ModuleBlock) { - addRange(statements, visitNodes((body).statements, namespaceElementVisitor, isStatement)); + saveStateAndInvoke(body, body => addRange(statements, visitNodes((body).statements, namespaceElementVisitor, isStatement))); statementsLocation = (body).statements; blockLocation = body; } diff --git a/tests/baselines/reference/metadataOfClassFromModule.js b/tests/baselines/reference/metadataOfClassFromModule.js index 8d9f97489f2cd..8ef120600df0e 100644 --- a/tests/baselines/reference/metadataOfClassFromModule.js +++ b/tests/baselines/reference/metadataOfClassFromModule.js @@ -38,7 +38,7 @@ var MyModule; }()); __decorate([ inject, - __metadata("design:type", Object) + __metadata("design:type", Leg) ], Person.prototype, "leftLeg", void 0); MyModule.Person = Person; })(MyModule || (MyModule = {})); From db1fda5e7755d3838f3131fc5f15175dc04197f4 Mon Sep 17 00:00:00 2001 From: Alexander Rusakov Date: Tue, 20 Dec 2016 17:55:14 +0300 Subject: [PATCH 23/24] Improve diagnostic message for negative old style literals --- src/compiler/checker.ts | 12 +++++++++--- src/compiler/diagnosticMessages.json | 6 +++--- src/compiler/utilities.ts | 5 +++++ tests/baselines/reference/literals.errors.txt | 6 +++--- .../reference/oldStyleOctalLiteralTypes.errors.txt | 6 +++--- .../reference/scannerNumericLiteral8.errors.txt | 6 +++--- 6 files changed, 26 insertions(+), 15 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 16b8c119b6369..2b815c40aba04 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -21857,11 +21857,17 @@ namespace ts { function checkGrammarNumericLiteral(node: NumericLiteral): boolean { // Grammar checking if (node.isOctalLiteral) { + let diagnosticMessage: DiagnosticMessage | undefined; if (languageVersion >= ScriptTarget.ES5) { - return grammarErrorOnNode(node, Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0o_0, node.text); + diagnosticMessage = Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0; } - if (isChildOfLiteralType(node)) { - return grammarErrorOnNode(node, Diagnostics.Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0o_0, node.text); + else if (isChildOfLiteralType(node)) { + diagnosticMessage = Diagnostics.Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0; + } + if (diagnosticMessage) { + const withMinus = isMinusPrefixUnaryExpression(node.parent); + const literal = `${withMinus ? "-" : ""}0o${node.text}`; + return grammarErrorOnNode(withMinus ? node.parent : node, diagnosticMessage, literal); } } } diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 6d19826e9519d..7b2208e4ca157 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -227,7 +227,7 @@ "category": "Error", "code": 1084 }, - "Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o{0}'.": { + "Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '{0}'.": { "category": "Error", "code": 1085 }, @@ -2952,7 +2952,7 @@ "Resolution for module '{0}' was found in cache": { "category": "Message", "code": 6147 - }, + }, "Variable '{0}' implicitly has an '{1}' type.": { "category": "Error", "code": 7005 @@ -3243,7 +3243,7 @@ "category": "Message", "code": 90015 }, - "Octal literal types must use ES2015 syntax. Use the syntax '0o{0}'.": { + "Octal literal types must use ES2015 syntax. Use the syntax '{0}'.": { "category": "Error", "code": 8017 } diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index c542fdb74f8bc..f272805ced2d1 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -742,6 +742,11 @@ namespace ts { return false; } + export function isMinusPrefixUnaryExpression(node: Node): boolean { + return node.kind === SyntaxKind.PrefixUnaryExpression && + (node as PrefixUnaryExpression).operator === SyntaxKind.MinusToken; + } + // Warning: This has the same semantics as the forEach family of functions, // in that traversal terminates in the event that 'visitor' supplies a truthy value. export function forEachReturnStatement(body: Block, visitor: (stmt: ReturnStatement) => T): T { diff --git a/tests/baselines/reference/literals.errors.txt b/tests/baselines/reference/literals.errors.txt index 2920498bde478..6fa1d7d3abd49 100644 --- a/tests/baselines/reference/literals.errors.txt +++ b/tests/baselines/reference/literals.errors.txt @@ -3,7 +3,7 @@ tests/cases/conformance/expressions/literals/literals.ts(9,17): error TS2363: Th tests/cases/conformance/expressions/literals/literals.ts(10,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/expressions/literals/literals.ts(10,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/expressions/literals/literals.ts(20,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o1'. -tests/cases/conformance/expressions/literals/literals.ts(25,10): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o3'. +tests/cases/conformance/expressions/literals/literals.ts(25,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '-0o3'. ==== tests/cases/conformance/expressions/literals/literals.ts (6 errors) ==== @@ -42,8 +42,8 @@ tests/cases/conformance/expressions/literals/literals.ts(25,10): error TS1085: O var n = -1.0; var n = -1e-4; var n = -003; // Error in ES5 - ~~~ -!!! error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o3'. + ~~~~ +!!! error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '-0o3'. var n = -0x1; var s: string; diff --git a/tests/baselines/reference/oldStyleOctalLiteralTypes.errors.txt b/tests/baselines/reference/oldStyleOctalLiteralTypes.errors.txt index 4dc81f370a40b..7d42963b05d92 100644 --- a/tests/baselines/reference/oldStyleOctalLiteralTypes.errors.txt +++ b/tests/baselines/reference/oldStyleOctalLiteralTypes.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/oldStyleOctalLiteralTypes.ts(1,8): error TS8017: Octal literal types must use ES2015 syntax. Use the syntax '0o10'. -tests/cases/compiler/oldStyleOctalLiteralTypes.ts(2,9): error TS8017: Octal literal types must use ES2015 syntax. Use the syntax '0o20'. +tests/cases/compiler/oldStyleOctalLiteralTypes.ts(2,8): error TS8017: Octal literal types must use ES2015 syntax. Use the syntax '-0o20'. ==== tests/cases/compiler/oldStyleOctalLiteralTypes.ts (2 errors) ==== @@ -7,6 +7,6 @@ tests/cases/compiler/oldStyleOctalLiteralTypes.ts(2,9): error TS8017: Octal lite ~~~ !!! error TS8017: Octal literal types must use ES2015 syntax. Use the syntax '0o10'. let y: -020; - ~~~ -!!! error TS8017: Octal literal types must use ES2015 syntax. Use the syntax '0o20'. + ~~~~ +!!! error TS8017: Octal literal types must use ES2015 syntax. Use the syntax '-0o20'. \ No newline at end of file diff --git a/tests/baselines/reference/scannerNumericLiteral8.errors.txt b/tests/baselines/reference/scannerNumericLiteral8.errors.txt index 5aad01449f283..6545050afc263 100644 --- a/tests/baselines/reference/scannerNumericLiteral8.errors.txt +++ b/tests/baselines/reference/scannerNumericLiteral8.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/scanner/ecmascript5/scannerNumericLiteral8.ts(1,2): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o3'. +tests/cases/conformance/scanner/ecmascript5/scannerNumericLiteral8.ts(1,1): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '-0o3'. ==== tests/cases/conformance/scanner/ecmascript5/scannerNumericLiteral8.ts (1 errors) ==== -03 - ~~ -!!! error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o3'. \ No newline at end of file + ~~~ +!!! error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '-0o3'. \ No newline at end of file From 23faaff03284d1414ce5374fddf59df4686cc06a Mon Sep 17 00:00:00 2001 From: arusakov Date: Thu, 22 Dec 2016 00:56:39 +0300 Subject: [PATCH 24/24] isMinusPrefixUnaryExpression() -> isPrefixUnaryExpression() after code review --- src/compiler/checker.ts | 2 +- src/compiler/utilities.ts | 5 ++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 2b815c40aba04..425d149db399e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -21865,7 +21865,7 @@ namespace ts { diagnosticMessage = Diagnostics.Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0; } if (diagnosticMessage) { - const withMinus = isMinusPrefixUnaryExpression(node.parent); + const withMinus = isPrefixUnaryExpression(node.parent) && node.parent.operator === SyntaxKind.MinusToken; const literal = `${withMinus ? "-" : ""}0o${node.text}`; return grammarErrorOnNode(withMinus ? node.parent : node, diagnosticMessage, literal); } diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index f272805ced2d1..edfbe639d25fd 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -742,9 +742,8 @@ namespace ts { return false; } - export function isMinusPrefixUnaryExpression(node: Node): boolean { - return node.kind === SyntaxKind.PrefixUnaryExpression && - (node as PrefixUnaryExpression).operator === SyntaxKind.MinusToken; + export function isPrefixUnaryExpression(node: Node): node is PrefixUnaryExpression { + return node.kind === SyntaxKind.PrefixUnaryExpression; } // Warning: This has the same semantics as the forEach family of functions,