From 64f17c5a9870fc452be98256402177a68105c30e Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Fri, 18 Nov 2016 07:48:12 -0800 Subject: [PATCH 01/45] Use a symbol for untyped modules to distinguish from unknownSymbol --- src/compiler/checker.ts | 16 ++++++----- src/compiler/utilities.ts | 4 +-- .../reference/extendsUntypedModule.errors.txt | 14 ++++++++++ .../reference/extendsUntypedModule.js | 27 +++++++++++++++++++ tests/cases/compiler/extendsUntypedModule.ts | 9 +++++++ tests/cases/fourslash/untypedModuleImport.ts | 2 +- 6 files changed, 63 insertions(+), 9 deletions(-) create mode 100644 tests/baselines/reference/extendsUntypedModule.errors.txt create mode 100644 tests/baselines/reference/extendsUntypedModule.js create mode 100644 tests/cases/compiler/extendsUntypedModule.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 3d25fc8bbbb..cf87755034e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1099,7 +1099,7 @@ namespace ts { const moduleSymbol = resolveExternalModuleName(node, (node.parent).moduleSpecifier); if (moduleSymbol) { - const exportDefaultSymbol = isShorthandAmbientModuleSymbol(moduleSymbol) ? + const exportDefaultSymbol = isUntypedOrShorthandAmbientModuleSymbol(moduleSymbol) ? moduleSymbol : moduleSymbol.exports["export="] ? getPropertyOfType(getTypeOfSymbol(moduleSymbol.exports["export="]), "default") : @@ -1175,7 +1175,7 @@ namespace ts { if (targetSymbol) { const name = specifier.propertyName || specifier.name; if (name.text) { - if (isShorthandAmbientModuleSymbol(moduleSymbol)) { + if (isUntypedOrShorthandAmbientModuleSymbol(moduleSymbol)) { return moduleSymbol; } @@ -1427,15 +1427,19 @@ namespace ts { Debug.assert(!!moduleNotFoundError); const diag = Diagnostics.Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented; error(errorNode, diag, moduleName, resolvedModule.resolvedFileName); + return undefined; } else if (compilerOptions.noImplicitAny && moduleNotFoundError) { error(errorNode, Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type, moduleReference, resolvedModule.resolvedFileName); + return undefined; } - // Failed imports and untyped modules are both treated in an untyped manner; only difference is whether we give a diagnostic first. - return undefined; + // Unlike a failed import, an untyped module produces a dummy symbol. This is checked for by `isUntypedOrShorthandAmbientModuleSymbol`. + const untypedSymbol = createSymbol(SymbolFlags.ValueModule, `"${moduleName}"`); + untypedSymbol.exports = createMap(); + return untypedSymbol; } if (moduleNotFoundError) { @@ -3575,7 +3579,7 @@ namespace ts { function getTypeOfFuncClassEnumModule(symbol: Symbol): Type { const links = getSymbolLinks(symbol); if (!links.type) { - if (symbol.flags & SymbolFlags.Module && isShorthandAmbientModuleSymbol(symbol)) { + if (symbol.flags & SymbolFlags.Module && isUntypedOrShorthandAmbientModuleSymbol(symbol)) { links.type = anyType; } else { @@ -19610,7 +19614,7 @@ namespace ts { function moduleExportsSomeValue(moduleReferenceExpression: Expression): boolean { let moduleSymbol = resolveExternalModuleName(moduleReferenceExpression.parent, moduleReferenceExpression); - if (!moduleSymbol || isShorthandAmbientModuleSymbol(moduleSymbol)) { + if (!moduleSymbol || isUntypedOrShorthandAmbientModuleSymbol(moduleSymbol)) { // If the module is not found or is shorthand, assume that it may export a value. return true; } diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 546416884f1..c6dfcebdc54 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -388,8 +388,8 @@ namespace ts { } /** Given a symbol for a module, checks that it is either an untyped import or a shorthand ambient module. */ - export function isShorthandAmbientModuleSymbol(moduleSymbol: Symbol): boolean { - return isShorthandAmbientModule(moduleSymbol.valueDeclaration); + export function isUntypedOrShorthandAmbientModuleSymbol(moduleSymbol: Symbol): boolean { + return !moduleSymbol.valueDeclaration || isShorthandAmbientModule(moduleSymbol.valueDeclaration); } function isShorthandAmbientModule(node: Node): boolean { diff --git a/tests/baselines/reference/extendsUntypedModule.errors.txt b/tests/baselines/reference/extendsUntypedModule.errors.txt new file mode 100644 index 00000000000..9a1c4235352 --- /dev/null +++ b/tests/baselines/reference/extendsUntypedModule.errors.txt @@ -0,0 +1,14 @@ +/a.ts(2,17): error TS2507: Type 'any' is not a constructor function type. + + +==== /a.ts (1 errors) ==== + import Foo from "foo"; + class A extends Foo { } + ~~~ +!!! error TS2507: Type 'any' is not a constructor function type. + +==== /node_modules/foo/index.js (0 errors) ==== + // Test that extending an untyped module is an error, unlike extending unknownSymbol. + + This file is not read. + \ No newline at end of file diff --git a/tests/baselines/reference/extendsUntypedModule.js b/tests/baselines/reference/extendsUntypedModule.js new file mode 100644 index 00000000000..0804595c08e --- /dev/null +++ b/tests/baselines/reference/extendsUntypedModule.js @@ -0,0 +1,27 @@ +//// [tests/cases/compiler/extendsUntypedModule.ts] //// + +//// [index.js] +// Test that extending an untyped module is an error, unlike extending unknownSymbol. + +This file is not read. + +//// [a.ts] +import Foo from "foo"; +class A extends Foo { } + + +//// [a.js] +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var foo_1 = require("foo"); +var A = (function (_super) { + __extends(A, _super); + function A() { + return _super.apply(this, arguments) || this; + } + return A; +}(foo_1["default"])); diff --git a/tests/cases/compiler/extendsUntypedModule.ts b/tests/cases/compiler/extendsUntypedModule.ts new file mode 100644 index 00000000000..8eaf6b3833a --- /dev/null +++ b/tests/cases/compiler/extendsUntypedModule.ts @@ -0,0 +1,9 @@ +// Test that extending an untyped module is an error, unlike extending unknownSymbol. +// @noImplicitReferences: true + +// @Filename: /node_modules/foo/index.js +This file is not read. + +// @Filename: /a.ts +import Foo from "foo"; +class A extends Foo { } diff --git a/tests/cases/fourslash/untypedModuleImport.ts b/tests/cases/fourslash/untypedModuleImport.ts index d128ad24ea3..3fd209d480d 100644 --- a/tests/cases/fourslash/untypedModuleImport.ts +++ b/tests/cases/fourslash/untypedModuleImport.ts @@ -13,7 +13,7 @@ verify.numberOfErrorsInCurrentFile(0); goTo.marker("fooModule"); verify.goToDefinitionIs([]); -verify.quickInfoIs(""); +verify.quickInfoIs('module "foo"'); verify.referencesAre([]) goTo.marker("foo"); From 4df4a2bbc7a1a71a440636f3bb18e5d9495569c8 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Wed, 25 Jan 2017 06:53:07 -0800 Subject: [PATCH 02/45] Use a single 'untypedModuleSymbol' for all untyped modules instead of creating a new one for each module. --- src/compiler/checker.ts | 10 ++++++---- .../baselines/reference/extendsUntypedModule.js | 17 +++++++++++------ tests/cases/fourslash/untypedModuleImport.ts | 2 +- 3 files changed, 18 insertions(+), 11 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 332031903db..224da5e69c2 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -132,6 +132,8 @@ namespace ts { const evolvingArrayTypes: EvolvingArrayType[] = []; const unknownSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "unknown"); + const untypedModuleSymbol = createSymbol(SymbolFlags.ValueModule, ""); + untypedModuleSymbol.exports = createMap(); const resolvingSymbol = createSymbol(SymbolFlags.Transient, "__resolving__"); const anyType = createIntrinsicType(TypeFlags.Any, "any"); @@ -1490,10 +1492,10 @@ namespace ts { resolvedModule.resolvedFileName); return undefined; } - // Unlike a failed import, an untyped module produces a dummy symbol. This is checked for by `isUntypedOrShorthandAmbientModuleSymbol`. - const untypedSymbol = createSymbol(SymbolFlags.ValueModule, `"${moduleName}"`); - untypedSymbol.exports = createMap(); - return untypedSymbol; + // Unlike a failed import, an untyped module produces a dummy symbol. + // This is checked for by `isUntypedOrShorthandAmbientModuleSymbol`. + // This must be different than `unknownSymbol` because `getBaseConstructorTypeOfClass` won't fail for `unknownSymbol`. + return untypedModuleSymbol; } if (moduleNotFoundError) { diff --git a/tests/baselines/reference/extendsUntypedModule.js b/tests/baselines/reference/extendsUntypedModule.js index 0804595c08e..ad35e4abaac 100644 --- a/tests/baselines/reference/extendsUntypedModule.js +++ b/tests/baselines/reference/extendsUntypedModule.js @@ -12,16 +12,21 @@ class A extends Foo { } //// [a.js] "use strict"; -var __extends = (this && this.__extends) || function (d, b) { - for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; - function __() { this.constructor = d; } - d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); -}; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); var foo_1 = require("foo"); var A = (function (_super) { __extends(A, _super); function A() { - return _super.apply(this, arguments) || this; + return _super !== null && _super.apply(this, arguments) || this; } return A; }(foo_1["default"])); diff --git a/tests/cases/fourslash/untypedModuleImport.ts b/tests/cases/fourslash/untypedModuleImport.ts index c09f710177b..276277102b0 100644 --- a/tests/cases/fourslash/untypedModuleImport.ts +++ b/tests/cases/fourslash/untypedModuleImport.ts @@ -12,7 +12,7 @@ verify.numberOfErrorsInCurrentFile(0); goTo.marker("fooModule"); verify.goToDefinitionIs([]); -verify.quickInfoIs('module "foo"'); +verify.quickInfoIs('module '); verify.referencesAre([]) goTo.marker("foo"); From 20cc428785b2e427b4689f303018683d921b5bbb Mon Sep 17 00:00:00 2001 From: Zhengbo Li Date: Fri, 10 Feb 2017 19:24:56 -0800 Subject: [PATCH 03/45] Fix jsdoc typedef symbol scope + avoid bind twice if the tag has a jsdoc namespace --- .gitignore | 1 + src/compiler/binder.ts | 59 +++++++++++++++++++ .../fourslash/server/jsdocTypedefTag1.ts | 20 +++++++ .../fourslash/server/jsdocTypedefTag2.ts | 30 ++++++++++ 4 files changed, 110 insertions(+) create mode 100644 tests/cases/fourslash/server/jsdocTypedefTag1.ts create mode 100644 tests/cases/fourslash/server/jsdocTypedefTag2.ts diff --git a/.gitignore b/.gitignore index f1ea04e3efb..a6c8c2940d8 100644 --- a/.gitignore +++ b/.gitignore @@ -57,3 +57,4 @@ internal/ !tests/cases/projects/NodeModulesSearch/**/* !tests/baselines/reference/project/nodeModules*/**/* .idea +yarn.lock \ No newline at end of file diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 04dc4011a15..446fadcc3b4 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -669,6 +669,12 @@ namespace ts { case SyntaxKind.CallExpression: bindCallExpressionFlow(node); break; + case SyntaxKind.JSDocComment: + bindJSDocComment(node); + break; + case SyntaxKind.JSDocTypedefTag: + bindJSDocTypedefTag(node); + break; default: bindEachChild(node); break; @@ -1298,6 +1304,26 @@ namespace ts { } } + function bindJSDocComment(node: JSDoc) { + forEachChild(node, n => { + if (n.kind !== SyntaxKind.JSDocTypedefTag) { + bind(n); + } + }); + } + + function bindJSDocTypedefTag(node: JSDocTypedefTag) { + forEachChild(node, n => { + // if the node has a fullName "A.B.C", that means symbol "C" was already bond + // when we visit "fullName"; so when we visit the name "C" as the next child of + // the jsDocTypedefTag, we should skip binding it. + if (n === node.name && node.fullName.kind !== SyntaxKind.Identifier) { + return; + } + bind(n); + }); + } + function bindCallExpressionFlow(node: CallExpression) { // If the target of the call expression is a function expression or arrow function we have // an immediately invoked function expression (IIFE). Initialize the flowNode property to @@ -1827,6 +1853,18 @@ namespace ts { } node.parent = parent; const saveInStrictMode = inStrictMode; + + // Even though in the AST the jsdoc @typedef node belongs to the current node, + // its symbol might be in the same scope with the current node's symbol. Consider: + // + // /** @typedef {string | number} MyType */ + // function foo(); + // + // Here the current node is "foo", which is a container, but the scope of "MyType" should + // not be inside "foo". Therefore we always bind @typedef before bind the parent node, + // and skip binding this tag later when binding all the other jsdoc tags. + bindJSDocTypedefTagIfAny(node); + // First we bind declaration nodes to a symbol if possible. We'll both create a symbol // and then potentially add the symbol to an appropriate symbol table. Possible // destination symbol tables are: @@ -1861,6 +1899,27 @@ namespace ts { inStrictMode = saveInStrictMode; } + function bindJSDocTypedefTagIfAny(node: Node) { + if (!node.jsDoc) { + return; + } + + for (const jsDoc of node.jsDoc) { + if (!jsDoc.tags) { + continue; + } + + for (const tag of jsDoc.tags) { + if (tag.kind === SyntaxKind.JSDocTypedefTag) { + const savedParent = parent; + parent = jsDoc; + bind(tag); + parent = savedParent; + } + } + } + } + function updateStrictModeStatementList(statements: NodeArray) { if (!inStrictMode) { for (const statement of statements) { diff --git a/tests/cases/fourslash/server/jsdocTypedefTag1.ts b/tests/cases/fourslash/server/jsdocTypedefTag1.ts new file mode 100644 index 00000000000..273dc1002af --- /dev/null +++ b/tests/cases/fourslash/server/jsdocTypedefTag1.ts @@ -0,0 +1,20 @@ +/// + +// @allowNonTsExtensions: true +// @Filename: jsdocCompletion_typedef.js + +//// /** +//// * @typedef {Object} MyType +//// * @property {string} yes +//// */ +//// function foo() { } + +//// /** +//// * @param {MyType} my +//// */ +//// function a(my) { +//// my.yes./*1*/ +//// } + +goTo.marker('1'); +verify.completionListContains('charAt'); \ No newline at end of file diff --git a/tests/cases/fourslash/server/jsdocTypedefTag2.ts b/tests/cases/fourslash/server/jsdocTypedefTag2.ts new file mode 100644 index 00000000000..60210935210 --- /dev/null +++ b/tests/cases/fourslash/server/jsdocTypedefTag2.ts @@ -0,0 +1,30 @@ +/// + +// @allowNonTsExtensions: true +// @Filename: jsdocCompletion_typedef.js + +//// /** +//// * @typedef {Object} A.B.MyType +//// * @property {string} yes +//// */ +//// function foo() {} + +//// /** +//// * @param {A.B.MyType} my2 +//// */ +//// function a(my2) { +//// my2.yes./*1*/ +//// } + +//// /** +//// * @param {MyType} my2 +//// */ +//// function b(my2) { +//// my2.yes./*2*/ +//// } + + +goTo.marker('1'); +verify.completionListContains('charAt'); +goTo.marker('2'); +verify.not.completionListContains('charAt'); \ No newline at end of file From de5091081a4768ff7684170d2ad8137cc02efaa0 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Tue, 14 Feb 2017 06:53:44 -0800 Subject: [PATCH 04/45] Fix failing tests --- src/compiler/utilities.ts | 2 +- tests/baselines/reference/extendsUntypedModule.js | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 6a338a0f9d2..f4c505b9450 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -426,7 +426,7 @@ namespace ts { /** Given a symbol for a module, checks that it is either an untyped import or a shorthand ambient module. */ export function isUntypedOrShorthandAmbientModuleSymbol(moduleSymbol: Symbol): boolean { - return !moduleSymbol.valueDeclaration || isShorthandAmbientModule(moduleSymbol.valueDeclaration); + return !moduleSymbol.declarations || isShorthandAmbientModule(moduleSymbol.valueDeclaration); } function isShorthandAmbientModule(node: Node): boolean { diff --git a/tests/baselines/reference/extendsUntypedModule.js b/tests/baselines/reference/extendsUntypedModule.js index ad35e4abaac..f86ded7e6cb 100644 --- a/tests/baselines/reference/extendsUntypedModule.js +++ b/tests/baselines/reference/extendsUntypedModule.js @@ -22,6 +22,7 @@ var __extends = (this && this.__extends) || (function () { d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; })(); +exports.__esModule = true; var foo_1 = require("foo"); var A = (function (_super) { __extends(A, _super); From 896e576374f3bbbb2e1781773664591608425af2 Mon Sep 17 00:00:00 2001 From: Zhengbo Li Date: Thu, 16 Feb 2017 13:17:42 -0800 Subject: [PATCH 05/45] fix typo --- src/compiler/binder.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 446fadcc3b4..493101f1688 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -1314,7 +1314,7 @@ namespace ts { function bindJSDocTypedefTag(node: JSDocTypedefTag) { forEachChild(node, n => { - // if the node has a fullName "A.B.C", that means symbol "C" was already bond + // if the node has a fullName "A.B.C", that means symbol "C" was already bound // when we visit "fullName"; so when we visit the name "C" as the next child of // the jsDocTypedefTag, we should skip binding it. if (n === node.name && node.fullName.kind !== SyntaxKind.Identifier) { From f6e9dad838b95ef6895d00333d7e1de9ab9de8cc Mon Sep 17 00:00:00 2001 From: Zhengbo Li Date: Thu, 16 Feb 2017 14:04:43 -0800 Subject: [PATCH 06/45] Check `fullName` has value for typedefTag --- src/compiler/binder.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 493101f1688..723148ba93e 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -1317,7 +1317,7 @@ namespace ts { // if the node has a fullName "A.B.C", that means symbol "C" was already bound // when we visit "fullName"; so when we visit the name "C" as the next child of // the jsDocTypedefTag, we should skip binding it. - if (n === node.name && node.fullName.kind !== SyntaxKind.Identifier) { + if (node.fullName && n === node.name && node.fullName.kind !== SyntaxKind.Identifier) { return; } bind(n); From 7d82e15ee50c3a8235875d9e2ffa99c9e9bc7ba5 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 16 Feb 2017 17:10:33 -0800 Subject: [PATCH 07/45] Add tests --- .../codeFixClassExtendAbstractGetter.ts | 11 ---------- .../codeFixClassExtendAbstractGetterSetter.ts | 22 +++++++++++++++---- .../codeFixClassExtendAbstractProperty.ts | 4 ++++ .../codeFixClassExtendAbstractSetter.ts | 11 ---------- 4 files changed, 22 insertions(+), 26 deletions(-) delete mode 100644 tests/cases/fourslash/codeFixClassExtendAbstractGetter.ts delete mode 100644 tests/cases/fourslash/codeFixClassExtendAbstractSetter.ts diff --git a/tests/cases/fourslash/codeFixClassExtendAbstractGetter.ts b/tests/cases/fourslash/codeFixClassExtendAbstractGetter.ts deleted file mode 100644 index 8d79cce710e..00000000000 --- a/tests/cases/fourslash/codeFixClassExtendAbstractGetter.ts +++ /dev/null @@ -1,11 +0,0 @@ -/// - -//// abstract class A { -//// abstract get b(): number; -//// } -//// -//// class C extends A {[| |]} - -verify.rangeAfterCodeFix(` - b: number; -`); \ No newline at end of file diff --git a/tests/cases/fourslash/codeFixClassExtendAbstractGetterSetter.ts b/tests/cases/fourslash/codeFixClassExtendAbstractGetterSetter.ts index fc0ac400623..4bddfb799f2 100644 --- a/tests/cases/fourslash/codeFixClassExtendAbstractGetterSetter.ts +++ b/tests/cases/fourslash/codeFixClassExtendAbstractGetterSetter.ts @@ -2,9 +2,17 @@ //// abstract class A { //// private _a: string; -//// -//// abstract get a(): string; -//// abstract set a(newName: string); +//// +//// abstract get a(): number | string; +//// abstract get b(): this; +//// abstract get c(): A; +//// +//// abstract set d(arg: number | string); +//// abstract set e(arg: this); +//// abstract set f(arg: A); +//// +//// abstract get g(): string; +//// abstract set g(newName: string); //// } //// //// // Don't need to add anything in this case. @@ -13,5 +21,11 @@ //// class C extends A {[| |]} verify.rangeAfterCodeFix(` - a: string; + a: string | number; + b: this; + c: A; + d: string | number; + e: this; + f: A; + g: string; `); \ No newline at end of file diff --git a/tests/cases/fourslash/codeFixClassExtendAbstractProperty.ts b/tests/cases/fourslash/codeFixClassExtendAbstractProperty.ts index 3160a3b9a08..b7300acf5ae 100644 --- a/tests/cases/fourslash/codeFixClassExtendAbstractProperty.ts +++ b/tests/cases/fourslash/codeFixClassExtendAbstractProperty.ts @@ -2,6 +2,8 @@ //// abstract class A { //// abstract x: number; +//// abstract y: this; +//// abstract z: A; //// abstract foo(): number; //// } //// @@ -10,6 +12,8 @@ verify.rangeAfterCodeFix(` x: number; + y: this; + z: A; foo(): number { throw new Error('Method not implemented.'); } diff --git a/tests/cases/fourslash/codeFixClassExtendAbstractSetter.ts b/tests/cases/fourslash/codeFixClassExtendAbstractSetter.ts deleted file mode 100644 index e8cb55fa660..00000000000 --- a/tests/cases/fourslash/codeFixClassExtendAbstractSetter.ts +++ /dev/null @@ -1,11 +0,0 @@ -/// - -//// abstract class A { -//// abstract set c(arg: number | string); -//// } -//// -//// class C extends A {[| |]} - -verify.rangeAfterCodeFix(` - c: string | number; -`); \ No newline at end of file From 33fc26cb9c4ea8e0ace668283abc81ac9a43c28b Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 16 Feb 2017 17:11:01 -0800 Subject: [PATCH 08/45] Detect this type for codefix --- src/services/codefixes/helpers.ts | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts index 3eab994f84c..45479e49474 100644 --- a/src/services/codefixes/helpers.ts +++ b/src/services/codefixes/helpers.ts @@ -23,8 +23,6 @@ namespace ts.codefix { * @returns Empty string iff there we can't figure out a representation for `symbol` in `enclosingDeclaration`. */ function getInsertionForMemberSymbol(symbol: Symbol, enclosingDeclaration: ClassLikeDeclaration, checker: TypeChecker, newlineChar: string): string { - // const name = symbol.getName(); - const type = checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration); const declarations = symbol.getDeclarations(); if (!(declarations && declarations.length)) { return ""; @@ -34,12 +32,22 @@ namespace ts.codefix { const name = declaration.name ? declaration.name.getText() : undefined; const visibility = getVisibilityPrefixWithSpace(getModifierFlags(declaration)); + const typeAtNewDeclaration = checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration); + switch (declaration.kind) { case SyntaxKind.GetAccessor: case SyntaxKind.SetAccessor: case SyntaxKind.PropertySignature: case SyntaxKind.PropertyDeclaration: - const typeString = checker.typeToString(type, enclosingDeclaration, TypeFormatFlags.None); + let typeString: string | undefined = undefined; + const typeAtOldDeclaration = checker.getTypeAtLocation(declaration); + if ((typeAtOldDeclaration as TypeParameter).isThisType) { + typeString = "this"; + } + else { + typeString = checker.typeToString(typeAtNewDeclaration, enclosingDeclaration, TypeFormatFlags.None); + } + return `${visibility}${name}: ${typeString};${newlineChar}`; case SyntaxKind.MethodSignature: @@ -51,7 +59,7 @@ namespace ts.codefix { // If there is more than one overload but no implementation signature // (eg: an abstract method or interface declaration), there is a 1-1 // correspondence of declarations and signatures. - const signatures = checker.getSignaturesOfType(type, SignatureKind.Call); + const signatures = checker.getSignaturesOfType(typeAtNewDeclaration, SignatureKind.Call); if (!(signatures && signatures.length > 0)) { return ""; } From 5ed5e5fd9432a5104de7a1e3459d0a6ea5951661 Mon Sep 17 00:00:00 2001 From: Klaus Meinhardt Date: Sun, 19 Feb 2017 18:38:09 +0100 Subject: [PATCH 09/45] Add CatchClause to VariableDeclaration.parent --- src/compiler/types.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index de42d5d9745..234e5570029 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -651,7 +651,7 @@ export interface VariableDeclaration extends Declaration { kind: SyntaxKind.VariableDeclaration; - parent?: VariableDeclarationList; + parent?: VariableDeclarationList | CatchClause; name: BindingName; // Declared variable name type?: TypeNode; // Optional type annotation initializer?: Expression; // Optional initializer From 077862736d00f9184ae89ae08f46f7b52333ebbd Mon Sep 17 00:00:00 2001 From: Klaus Meinhardt Date: Sun, 19 Feb 2017 21:26:04 +0100 Subject: [PATCH 10/45] Add parent type for nodes where possible --- src/compiler/types.ts | 37 ++++++++++++++++++++++++++++++++++++- 1 file changed, 36 insertions(+), 1 deletion(-) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 234e5570029..3d93907ae98 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -624,6 +624,7 @@ export interface TypeParameterDeclaration extends Declaration { kind: SyntaxKind.TypeParameter; + parent?: DeclarationWithTypeParameters; name: Identifier; constraint?: TypeNode; default?: TypeNode; @@ -659,11 +660,13 @@ export interface VariableDeclarationList extends Node { kind: SyntaxKind.VariableDeclarationList; + parent?: VariableStatement | ForStatement | ForOfStatement | ForInStatement; declarations: NodeArray; } export interface ParameterDeclaration extends Declaration { kind: SyntaxKind.Parameter; + parent?: SignatureDeclaration; dotDotDotToken?: DotDotDotToken; // Present on rest parameter name: BindingName; // Declared parameter name questionToken?: QuestionToken; // Present on optional parameter @@ -673,6 +676,7 @@ export interface BindingElement extends Declaration { kind: SyntaxKind.BindingElement; + parent?: BindingPattern; propertyName?: PropertyName; // Binding property name (in object binding pattern) dotDotDotToken?: DotDotDotToken; // Present on rest element (in object binding pattern) name: BindingName; // Declared binding element name @@ -754,11 +758,13 @@ export interface ObjectBindingPattern extends Node { kind: SyntaxKind.ObjectBindingPattern; + parent?: VariableDeclaration | ParameterDeclaration | BindingElement; elements: NodeArray; } export interface ArrayBindingPattern extends Node { kind: SyntaxKind.ArrayBindingPattern; + parent?: VariableDeclaration | ParameterDeclaration | BindingElement; elements: NodeArray; } @@ -1327,14 +1333,17 @@ export interface TemplateHead extends LiteralLikeNode { kind: SyntaxKind.TemplateHead; + parent?: TemplateExpression; } export interface TemplateMiddle extends LiteralLikeNode { kind: SyntaxKind.TemplateMiddle; + parent?: TemplateSpan; } export interface TemplateTail extends LiteralLikeNode { kind: SyntaxKind.TemplateTail; + parent?: TemplateSpan; } export type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral; @@ -1349,6 +1358,7 @@ // The template literal must have kind TemplateMiddleLiteral or TemplateTailLiteral. export interface TemplateSpan extends Node { kind: SyntaxKind.TemplateSpan; + parent?: TemplateExpression; expression: Expression; literal: TemplateMiddle | TemplateTail; } @@ -1503,6 +1513,7 @@ /// The opening element of a ... JsxElement export interface JsxOpeningElement extends Expression { kind: SyntaxKind.JsxOpeningElement; + parent?: JsxElement; tagName: JsxTagNameExpression; attributes: JsxAttributes; } @@ -1516,6 +1527,7 @@ export interface JsxAttribute extends ObjectLiteralElement { kind: SyntaxKind.JsxAttribute; + parent?: JsxOpeningLikeElement; name: Identifier; /// JSX attribute initializers are optional; is sugar for initializer?: StringLiteral | JsxExpression; @@ -1523,22 +1535,26 @@ export interface JsxSpreadAttribute extends ObjectLiteralElement { kind: SyntaxKind.JsxSpreadAttribute; + parent?: JsxOpeningLikeElement; expression: Expression; } export interface JsxClosingElement extends Node { kind: SyntaxKind.JsxClosingElement; + parent?: JsxElement; tagName: JsxTagNameExpression; } export interface JsxExpression extends Expression { kind: SyntaxKind.JsxExpression; + parent?: JsxElement | JsxAttributeLike; dotDotDotToken?: Token; expression?: Expression; } export interface JsxText extends Node { kind: SyntaxKind.JsxText; + parent?: JsxElement; } export type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement; @@ -1680,17 +1696,20 @@ export interface CaseBlock extends Node { kind: SyntaxKind.CaseBlock; + parent?: SwitchStatement; clauses: NodeArray; } export interface CaseClause extends Node { kind: SyntaxKind.CaseClause; + parent?: CaseBlock; expression: Expression; statements: NodeArray; } export interface DefaultClause extends Node { kind: SyntaxKind.DefaultClause; + parent?: CaseBlock; statements: NodeArray; } @@ -1716,6 +1735,7 @@ export interface CatchClause extends Node { kind: SyntaxKind.CatchClause; + parent?: TryStatement; variableDeclaration: VariableDeclaration; block: Block; } @@ -1759,6 +1779,7 @@ export interface HeritageClause extends Node { kind: SyntaxKind.HeritageClause; + parent?: InterfaceDeclaration | ClassDeclaration | ClassExpression; token: SyntaxKind; types?: NodeArray; } @@ -1772,6 +1793,7 @@ export interface EnumMember extends Declaration { kind: SyntaxKind.EnumMember; + parent?: EnumDeclaration; // This does include ComputedPropertyName, but the parser will give an error // if it parses a ComputedPropertyName in an EnumMember name: PropertyName; @@ -1790,7 +1812,8 @@ export interface ModuleDeclaration extends DeclarationStatement { kind: SyntaxKind.ModuleDeclaration; - name: Identifier | StringLiteral; + parent?: ModuleBody | SourceFile; + name: ModuleName; body?: ModuleBody | JSDocNamespaceDeclaration | Identifier; } @@ -1810,6 +1833,7 @@ export interface ModuleBlock extends Node, Statement { kind: SyntaxKind.ModuleBlock; + parent?: ModuleDeclaration; statements: NodeArray; } @@ -1817,6 +1841,7 @@ export interface ImportEqualsDeclaration extends DeclarationStatement { kind: SyntaxKind.ImportEqualsDeclaration; + parent?: SourceFile | ModuleBlock; name: Identifier; // 'EntityName' for an internal module reference, 'ExternalModuleReference' for an external @@ -1826,6 +1851,7 @@ export interface ExternalModuleReference extends Node { kind: SyntaxKind.ExternalModuleReference; + parent?: ImportEqualsDeclaration; expression?: Expression; } @@ -1835,6 +1861,7 @@ // ImportClause information is shown at its declaration below. export interface ImportDeclaration extends Statement { kind: SyntaxKind.ImportDeclaration; + parent?: SourceFile | ModuleBlock; importClause?: ImportClause; moduleSpecifier: Expression; } @@ -1849,12 +1876,14 @@ // import d, { a, b as x } from "mod" => name = d, namedBinding: NamedImports = { elements: [{ name: a }, { name: x, propertyName: b}]} export interface ImportClause extends Declaration { kind: SyntaxKind.ImportClause; + parent?: ImportDeclaration; name?: Identifier; // Default binding namedBindings?: NamedImportBindings; } export interface NamespaceImport extends Declaration { kind: SyntaxKind.NamespaceImport; + parent?: ImportClause; name: Identifier; } @@ -1866,17 +1895,20 @@ export interface ExportDeclaration extends DeclarationStatement { kind: SyntaxKind.ExportDeclaration; + parent?: SourceFile | ModuleBlock; exportClause?: NamedExports; moduleSpecifier?: Expression; } export interface NamedImports extends Node { kind: SyntaxKind.NamedImports; + parent?: ImportClause; elements: NodeArray; } export interface NamedExports extends Node { kind: SyntaxKind.NamedExports; + parent?: ExportDeclaration; elements: NodeArray; } @@ -1884,12 +1916,14 @@ export interface ImportSpecifier extends Declaration { kind: SyntaxKind.ImportSpecifier; + parent?: NamedImports; propertyName?: Identifier; // Name preceding "as" keyword (or undefined when "as" is absent) name: Identifier; // Declared name } export interface ExportSpecifier extends Declaration { kind: SyntaxKind.ExportSpecifier; + parent?: NamedExports; propertyName?: Identifier; // Name preceding "as" keyword (or undefined when "as" is absent) name: Identifier; // Declared name } @@ -1898,6 +1932,7 @@ export interface ExportAssignment extends DeclarationStatement { kind: SyntaxKind.ExportAssignment; + parent?: SourceFile; isExportEquals?: boolean; expression: Expression; } From 6c9ba46e8b9253e95d899a9d6fbef2aba16ba4b9 Mon Sep 17 00:00:00 2001 From: Klaus Meinhardt Date: Sun, 19 Feb 2017 22:03:32 +0100 Subject: [PATCH 11/45] Fix compile errors --- src/compiler/checker.ts | 2 +- src/services/breakpoints.ts | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 12b55aa818b..541b49acb9a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -11546,7 +11546,7 @@ namespace ts { if (isBindingPattern(declaration.parent)) { const parentDeclaration = declaration.parent.parent; const name = declaration.propertyName || declaration.name; - if (isVariableLike(parentDeclaration) && + if (parentDeclaration.kind !== SyntaxKind.BindingElement && parentDeclaration.type && !isBindingPattern(name)) { const text = getTextOfPropertyName(name); diff --git a/src/services/breakpoints.ts b/src/services/breakpoints.ts index c751cf3871b..1f6bec41109 100644 --- a/src/services/breakpoints.ts +++ b/src/services/breakpoints.ts @@ -370,8 +370,8 @@ namespace ts.BreakpointResolver { } function textSpanFromVariableDeclaration(variableDeclaration: VariableDeclaration): TextSpan { - const declarations = variableDeclaration.parent.declarations; - if (declarations && declarations[0] === variableDeclaration) { + if (variableDeclaration.parent.kind === SyntaxKind.VariableDeclarationList && + variableDeclaration.parent.declarations[0] === variableDeclaration) { // First declaration - include let keyword return textSpan(findPrecedingToken(variableDeclaration.pos, sourceFile, variableDeclaration.parent), variableDeclaration); } @@ -400,8 +400,8 @@ namespace ts.BreakpointResolver { return textSpanFromVariableDeclaration(variableDeclaration); } - const declarations = variableDeclaration.parent.declarations; - if (declarations && declarations[0] !== variableDeclaration) { + if (variableDeclaration.parent.kind === SyntaxKind.VariableDeclarationList && + variableDeclaration.parent.declarations[0] !== variableDeclaration) { // If we cannot set breakpoint on this declaration, set it on previous one // Because the variable declaration may be binding pattern and // we would like to set breakpoint in last binding element if that's the case, From 1c25034a18d736e07a3f6ad9fb05c3450929e8d3 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 22 Feb 2017 16:15:16 -0800 Subject: [PATCH 12/45] instantiate generic this param correctly --- src/compiler/checker.ts | 1 + src/compiler/types.ts | 1 + ...sDoesntImplementInheritedAbstractMember.ts | 2 +- .../fixClassIncorrectlyImplementsInterface.ts | 4 +-- src/services/codefixes/helpers.ts | 14 ++------ .../codeFixClassExtendAbstractMethod.ts | 2 ++ .../codeFixClassExtendAbstractMethodThis.ts | 13 +++++++ ...entInterfaceMethodThisAndSelfReference.ts} | 4 +-- tests/cases/fourslash/quickInfoOnThis5.ts | 35 +++++++++++++++++++ 9 files changed, 60 insertions(+), 16 deletions(-) create mode 100644 tests/cases/fourslash/codeFixClassExtendAbstractMethodThis.ts rename tests/cases/fourslash/{codeFixClassImplementInterfaceMethodWithParams.ts => codeFixClassImplementInterfaceMethodThisAndSelfReference.ts} (71%) create mode 100644 tests/cases/fourslash/quickInfoOnThis5.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 12b55aa818b..8b926832200 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -97,6 +97,7 @@ namespace ts { getBaseTypes, getBaseTypeOfLiteralType, getWidenedType, + getTypeWithThisArgument, getTypeFromTypeNode: node => { node = getParseTreeNode(node, isTypeNode); return node ? getTypeFromTypeNode(node) : unknownType; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index de42d5d9745..f4e432bc536 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2411,6 +2411,7 @@ getIndexTypeOfType(type: Type, kind: IndexKind): Type; getBaseTypes(type: InterfaceType): BaseType[]; getBaseTypeOfLiteralType(type: Type): Type; + getTypeWithThisArgument(type: Type, thisArgument?: Type): Type; getWidenedType(type: Type): Type; getReturnTypeOfSignature(signature: Signature): Type; /** diff --git a/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts b/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts index 22546e55ecc..f7e0fde8d43 100644 --- a/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts +++ b/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts @@ -23,7 +23,7 @@ namespace ts.codefix { const startPos = classDecl.members.pos; const classType = checker.getTypeAtLocation(classDecl) as InterfaceType; - const instantiatedExtendsType = checker.getBaseTypes(classType)[0]; + const instantiatedExtendsType = checker.getTypeWithThisArgument(checker.getBaseTypes(classType)[0], classType.thisType); // Note that this is ultimately derived from a map indexed by symbol names, // so duplicates cannot occur. diff --git a/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts b/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts index 42488dc2aed..aa7b320b13c 100644 --- a/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts +++ b/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts @@ -17,7 +17,7 @@ namespace ts.codefix { } const startPos: number = classDecl.members.pos; - const classType = checker.getTypeAtLocation(classDecl); + const classType = checker.getTypeAtLocation(classDecl) as InterfaceType; const implementedTypeNodes = getClassImplementsHeritageClauseElements(classDecl); const hasNumericIndexSignature = !!checker.getIndexTypeOfType(classType, IndexKind.Number); @@ -25,7 +25,7 @@ namespace ts.codefix { const result: CodeAction[] = []; for (const implementedTypeNode of implementedTypeNodes) { - const implementedType = checker.getTypeFromTypeNode(implementedTypeNode) as InterfaceType; + const implementedType = checker.getTypeWithThisArgument(checker.getTypeFromTypeNode(implementedTypeNode), classType.thisType) as InterfaceType; // Note that this is ultimately derived from a map indexed by symbol names, // so duplicates cannot occur. const implementedTypeSymbols = checker.getPropertiesOfType(implementedType); diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts index 45479e49474..d20fc0129cd 100644 --- a/src/services/codefixes/helpers.ts +++ b/src/services/codefixes/helpers.ts @@ -32,22 +32,14 @@ namespace ts.codefix { const name = declaration.name ? declaration.name.getText() : undefined; const visibility = getVisibilityPrefixWithSpace(getModifierFlags(declaration)); - const typeAtNewDeclaration = checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration); + const type = checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration); switch (declaration.kind) { case SyntaxKind.GetAccessor: case SyntaxKind.SetAccessor: case SyntaxKind.PropertySignature: case SyntaxKind.PropertyDeclaration: - let typeString: string | undefined = undefined; - const typeAtOldDeclaration = checker.getTypeAtLocation(declaration); - if ((typeAtOldDeclaration as TypeParameter).isThisType) { - typeString = "this"; - } - else { - typeString = checker.typeToString(typeAtNewDeclaration, enclosingDeclaration, TypeFormatFlags.None); - } - + const typeString = checker.typeToString(type, enclosingDeclaration, TypeFormatFlags.None); return `${visibility}${name}: ${typeString};${newlineChar}`; case SyntaxKind.MethodSignature: @@ -59,7 +51,7 @@ namespace ts.codefix { // If there is more than one overload but no implementation signature // (eg: an abstract method or interface declaration), there is a 1-1 // correspondence of declarations and signatures. - const signatures = checker.getSignaturesOfType(typeAtNewDeclaration, SignatureKind.Call); + const signatures = checker.getSignaturesOfType(type, SignatureKind.Call); if (!(signatures && signatures.length > 0)) { return ""; } diff --git a/tests/cases/fourslash/codeFixClassExtendAbstractMethod.ts b/tests/cases/fourslash/codeFixClassExtendAbstractMethod.ts index a657dfeb718..344a7ee3f2b 100644 --- a/tests/cases/fourslash/codeFixClassExtendAbstractMethod.ts +++ b/tests/cases/fourslash/codeFixClassExtendAbstractMethod.ts @@ -2,6 +2,7 @@ //// abstract class A { //// abstract f(a: number, b: string): boolean; +//// abstract f(a: number, b: string): this; //// abstract f(a: string, b: number): Function; //// abstract f(a: string): Function; //// } @@ -10,6 +11,7 @@ verify.rangeAfterCodeFix(` f(a: number, b: string): boolean; + f(a: number, b: string): this; f(a: string, b: number): Function; f(a: string): Function; f(a: any, b?: any) { diff --git a/tests/cases/fourslash/codeFixClassExtendAbstractMethodThis.ts b/tests/cases/fourslash/codeFixClassExtendAbstractMethodThis.ts new file mode 100644 index 00000000000..55b3ad4b77e --- /dev/null +++ b/tests/cases/fourslash/codeFixClassExtendAbstractMethodThis.ts @@ -0,0 +1,13 @@ +/// + +//// abstract class A { +//// abstract f(): this; +//// } +//// +//// class C extends A {[| |]} + +verify.rangeAfterCodeFix(` + f(): this { + throw new Error('Method not implemented.'); + } +`); diff --git a/tests/cases/fourslash/codeFixClassImplementInterfaceMethodWithParams.ts b/tests/cases/fourslash/codeFixClassImplementInterfaceMethodThisAndSelfReference.ts similarity index 71% rename from tests/cases/fourslash/codeFixClassImplementInterfaceMethodWithParams.ts rename to tests/cases/fourslash/codeFixClassImplementInterfaceMethodThisAndSelfReference.ts index 0ee842975e0..95cc3476bf1 100644 --- a/tests/cases/fourslash/codeFixClassImplementInterfaceMethodWithParams.ts +++ b/tests/cases/fourslash/codeFixClassImplementInterfaceMethodThisAndSelfReference.ts @@ -1,14 +1,14 @@ /// //// interface I { -//// f(x: number, y: string): I +//// f(x: number, y: this): I //// } //// //// class C implements I {[| //// |]} verify.rangeAfterCodeFix(` -f(x: number,y: string): I { +f(x: number,y: this): I { throw new Error('Method not implemented.'); } `); diff --git a/tests/cases/fourslash/quickInfoOnThis5.ts b/tests/cases/fourslash/quickInfoOnThis5.ts new file mode 100644 index 00000000000..fd09aeb4a07 --- /dev/null +++ b/tests/cases/fourslash/quickInfoOnThis5.ts @@ -0,0 +1,35 @@ +/// + +verify.quickInfos({ + 1: "this: ContextualInterface", + 2: "(parameter) this: void" +}); + + + +////interface ContextualInterface { +//// m: number; +//// method(this: this, n: number); +////} +////let o: ContextualInterface = { +//// m: 12, +//// method(n) { +//// let x = this/*1*/.m; +//// } +////} +////interface ContextualInterface2 { +//// (this: void, n: number): void; +////} +////let contextualInterface2: ContextualInterface2 = function (th/*2*/is, n) { } + +class A { + x: number + myMethod(): this { return this; } +} + +class B extends A { + constructor(){ + super(); + this.myMethod(); + } +} From fbccb62d4b7a25994b3adfc87e80029f9d4b5ef9 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 22 Feb 2017 16:20:14 -0800 Subject: [PATCH 13/45] cleanup tests --- tests/cases/fourslash/quickInfoOnThis5.ts | 35 ----------------------- 1 file changed, 35 deletions(-) delete mode 100644 tests/cases/fourslash/quickInfoOnThis5.ts diff --git a/tests/cases/fourslash/quickInfoOnThis5.ts b/tests/cases/fourslash/quickInfoOnThis5.ts deleted file mode 100644 index fd09aeb4a07..00000000000 --- a/tests/cases/fourslash/quickInfoOnThis5.ts +++ /dev/null @@ -1,35 +0,0 @@ -/// - -verify.quickInfos({ - 1: "this: ContextualInterface", - 2: "(parameter) this: void" -}); - - - -////interface ContextualInterface { -//// m: number; -//// method(this: this, n: number); -////} -////let o: ContextualInterface = { -//// m: 12, -//// method(n) { -//// let x = this/*1*/.m; -//// } -////} -////interface ContextualInterface2 { -//// (this: void, n: number): void; -////} -////let contextualInterface2: ContextualInterface2 = function (th/*2*/is, n) { } - -class A { - x: number - myMethod(): this { return this; } -} - -class B extends A { - constructor(){ - super(); - this.myMethod(); - } -} From fd8040978b0d3ab688488876e1d169bf32681420 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Thu, 23 Feb 2017 21:25:30 -0800 Subject: [PATCH 14/45] Allow primitive types in JSDoc to start wtih uppercase letters --- src/compiler/checker.ts | 52 +++++-- src/compiler/types.ts | 7 +- tests/baselines/reference/jsDocTypes.js | 137 ++++++++++++++++++ tests/baselines/reference/jsDocTypes.symbols | 133 +++++++++++++++++ tests/baselines/reference/jsDocTypes.types | 136 +++++++++++++++++ ...ileCompilationRestParamJsDocFunction.types | 16 +- tests/cases/conformance/salsa/jsDocTypes.ts | 80 ++++++++++ 7 files changed, 538 insertions(+), 23 deletions(-) create mode 100644 tests/baselines/reference/jsDocTypes.js create mode 100644 tests/baselines/reference/jsDocTypes.symbols create mode 100644 tests/baselines/reference/jsDocTypes.types create mode 100644 tests/cases/conformance/salsa/jsDocTypes.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 83fea11c993..ac5012a3bf9 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -5897,15 +5897,52 @@ namespace ts { return getTypeFromNonGenericTypeReference(node, symbol); } + function getPrimitiveTypeFromJSDocTypeReference(node: JSDocTypeReference): Type { + if (isIdentifier(node.name)) { + switch (node.name.text) { + case "String": + return stringType; + case "Number": + return numberType; + case "Boolean": + return booleanType; + case "Void": + return voidType; + case "Undefined": + return undefinedType; + case "Null": + return nullType; + case "Object": + return anyType; + case "Function": + return anyFunctionType; + case "Array": + case "array": + return !node.typeArguments || !node.typeArguments.length ? createArrayType(anyType) : undefined; + case "Promise": + case "promise": + return !node.typeArguments || !node.typeArguments.length ? createPromiseType(anyType) : undefined; + } + } + } + + function getTypeFromJSDocNullableTypeNode(node: JSDocNullableType) { + const type = getTypeFromTypeNode(node.type); + return strictNullChecks ? getUnionType([type, nullType]) : type; + } + function getTypeFromTypeReference(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference): Type { const links = getNodeLinks(node); if (!links.resolvedType) { let symbol: Symbol; let type: Type; if (node.kind === SyntaxKind.JSDocTypeReference) { - const typeReferenceName = getTypeReferenceName(node); - symbol = resolveTypeReferenceName(typeReferenceName); - type = getTypeReferenceType(node, symbol); + type = getPrimitiveTypeFromJSDocTypeReference(node); + if (!type) { + const typeReferenceName = getTypeReferenceName(node); + symbol = resolveTypeReferenceName(typeReferenceName); + type = getTypeReferenceType(node, symbol); + } } else { // We only support expressions that are simple qualified names. For other expressions this produces undefined. @@ -6812,12 +6849,6 @@ namespace ts { return neverType; case SyntaxKind.ObjectKeyword: return nonPrimitiveType; - case SyntaxKind.JSDocNullKeyword: - return nullType; - case SyntaxKind.JSDocUndefinedKeyword: - return undefinedType; - case SyntaxKind.JSDocNeverKeyword: - return neverType; case SyntaxKind.ThisType: case SyntaxKind.ThisKeyword: return getTypeFromThisTypeNode(node); @@ -6844,8 +6875,9 @@ namespace ts { return getTypeFromUnionTypeNode(node); case SyntaxKind.IntersectionType: return getTypeFromIntersectionTypeNode(node); - case SyntaxKind.ParenthesizedType: case SyntaxKind.JSDocNullableType: + return getTypeFromJSDocNullableTypeNode(node); + case SyntaxKind.ParenthesizedType: case SyntaxKind.JSDocNonNullableType: case SyntaxKind.JSDocConstructorType: case SyntaxKind.JSDocThisType: diff --git a/src/compiler/types.ts b/src/compiler/types.ts index de42d5d9745..df851eb07df 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -381,9 +381,6 @@ JSDocPropertyTag, JSDocTypeLiteral, JSDocLiteralType, - JSDocNullKeyword, - JSDocUndefinedKeyword, - JSDocNeverKeyword, // Synthesized list SyntaxList, @@ -423,9 +420,9 @@ LastBinaryOperator = CaretEqualsToken, FirstNode = QualifiedName, FirstJSDocNode = JSDocTypeExpression, - LastJSDocNode = JSDocNeverKeyword, + LastJSDocNode = JSDocLiteralType, FirstJSDocTagNode = JSDocComment, - LastJSDocTagNode = JSDocNeverKeyword + LastJSDocTagNode = JSDocLiteralType } export const enum NodeFlags { diff --git a/tests/baselines/reference/jsDocTypes.js b/tests/baselines/reference/jsDocTypes.js new file mode 100644 index 00000000000..a6df2f361c6 --- /dev/null +++ b/tests/baselines/reference/jsDocTypes.js @@ -0,0 +1,137 @@ +//// [tests/cases/conformance/salsa/jsDocTypes.ts] //// + +//// [a.js] + +/** @type {String} */ +var S; + +/** @type {string} */ +var s; + +/** @type {Number} */ +var N; + +/** @type {number} */ +var n; + +/** @type {Boolean} */ +var B; + +/** @type {boolean} */ +var b; + +/** @type {Void} */ +var V; + +/** @type {void} */ +var v; + +/** @type {Undefined} */ +var U; + +/** @type {undefined} */ +var u; + +/** @type {Null} */ +var Nl; + +/** @type {null} */ +var nl; + +/** @type {Array} */ +var A; + +/** @type {array} */ +var a; + +/** @type {Promise} */ +var P; + +/** @type {promise} */ +var p; + +/** @type {?number} */ +var nullable; + +/** @type {Object} */ +var Obj; + + + +//// [b.ts] +var S: string; +var s: string; +var N: number; +var n: number +var B: boolean; +var b: boolean; +var V :void; +var v: void; +var U: undefined; +var u: undefined; +var Nl: null; +var nl: null; +var A: any[]; +var a: any[]; +var P: Promise; +var p: Promise; +var nullable: number | null; +var Obj: any; + + +//// [a.js] +/** @type {String} */ +var S; +/** @type {string} */ +var s; +/** @type {Number} */ +var N; +/** @type {number} */ +var n; +/** @type {Boolean} */ +var B; +/** @type {boolean} */ +var b; +/** @type {Void} */ +var V; +/** @type {void} */ +var v; +/** @type {Undefined} */ +var U; +/** @type {undefined} */ +var u; +/** @type {Null} */ +var Nl; +/** @type {null} */ +var nl; +/** @type {Array} */ +var A; +/** @type {array} */ +var a; +/** @type {Promise} */ +var P; +/** @type {promise} */ +var p; +/** @type {?number} */ +var nullable; +/** @type {Object} */ +var Obj; +//// [b.js] +var S; +var s; +var N; +var n; +var B; +var b; +var V; +var v; +var U; +var u; +var Nl; +var nl; +var A; +var a; +var P; +var p; +var nullable; +var Obj; diff --git a/tests/baselines/reference/jsDocTypes.symbols b/tests/baselines/reference/jsDocTypes.symbols new file mode 100644 index 00000000000..9bde032cb44 --- /dev/null +++ b/tests/baselines/reference/jsDocTypes.symbols @@ -0,0 +1,133 @@ +=== tests/cases/conformance/salsa/a.js === + +/** @type {String} */ +var S; +>S : Symbol(S, Decl(a.js, 2, 3), Decl(b.ts, 0, 3)) + +/** @type {string} */ +var s; +>s : Symbol(s, Decl(a.js, 5, 3), Decl(b.ts, 1, 3)) + +/** @type {Number} */ +var N; +>N : Symbol(N, Decl(a.js, 8, 3), Decl(b.ts, 2, 3)) + +/** @type {number} */ +var n; +>n : Symbol(n, Decl(a.js, 11, 3), Decl(b.ts, 3, 3)) + +/** @type {Boolean} */ +var B; +>B : Symbol(B, Decl(a.js, 14, 3), Decl(b.ts, 4, 3)) + +/** @type {boolean} */ +var b; +>b : Symbol(b, Decl(a.js, 17, 3), Decl(b.ts, 5, 3)) + +/** @type {Void} */ +var V; +>V : Symbol(V, Decl(a.js, 20, 3), Decl(b.ts, 6, 3)) + +/** @type {void} */ +var v; +>v : Symbol(v, Decl(a.js, 23, 3), Decl(b.ts, 7, 3)) + +/** @type {Undefined} */ +var U; +>U : Symbol(U, Decl(a.js, 26, 3), Decl(b.ts, 8, 3)) + +/** @type {undefined} */ +var u; +>u : Symbol(u, Decl(a.js, 29, 3), Decl(b.ts, 9, 3)) + +/** @type {Null} */ +var Nl; +>Nl : Symbol(Nl, Decl(a.js, 32, 3), Decl(b.ts, 10, 3)) + +/** @type {null} */ +var nl; +>nl : Symbol(nl, Decl(a.js, 35, 3), Decl(b.ts, 11, 3)) + +/** @type {Array} */ +var A; +>A : Symbol(A, Decl(a.js, 38, 3), Decl(b.ts, 12, 3)) + +/** @type {array} */ +var a; +>a : Symbol(a, Decl(a.js, 41, 3), Decl(b.ts, 13, 3)) + +/** @type {Promise} */ +var P; +>P : Symbol(P, Decl(a.js, 44, 3), Decl(b.ts, 14, 3)) + +/** @type {promise} */ +var p; +>p : Symbol(p, Decl(a.js, 47, 3), Decl(b.ts, 15, 3)) + +/** @type {?number} */ +var nullable; +>nullable : Symbol(nullable, Decl(a.js, 50, 3), Decl(b.ts, 16, 3)) + +/** @type {Object} */ +var Obj; +>Obj : Symbol(Obj, Decl(a.js, 53, 3), Decl(b.ts, 17, 3)) + + + +=== tests/cases/conformance/salsa/b.ts === +var S: string; +>S : Symbol(S, Decl(a.js, 2, 3), Decl(b.ts, 0, 3)) + +var s: string; +>s : Symbol(s, Decl(a.js, 5, 3), Decl(b.ts, 1, 3)) + +var N: number; +>N : Symbol(N, Decl(a.js, 8, 3), Decl(b.ts, 2, 3)) + +var n: number +>n : Symbol(n, Decl(a.js, 11, 3), Decl(b.ts, 3, 3)) + +var B: boolean; +>B : Symbol(B, Decl(a.js, 14, 3), Decl(b.ts, 4, 3)) + +var b: boolean; +>b : Symbol(b, Decl(a.js, 17, 3), Decl(b.ts, 5, 3)) + +var V :void; +>V : Symbol(V, Decl(a.js, 20, 3), Decl(b.ts, 6, 3)) + +var v: void; +>v : Symbol(v, Decl(a.js, 23, 3), Decl(b.ts, 7, 3)) + +var U: undefined; +>U : Symbol(U, Decl(a.js, 26, 3), Decl(b.ts, 8, 3)) + +var u: undefined; +>u : Symbol(u, Decl(a.js, 29, 3), Decl(b.ts, 9, 3)) + +var Nl: null; +>Nl : Symbol(Nl, Decl(a.js, 32, 3), Decl(b.ts, 10, 3)) + +var nl: null; +>nl : Symbol(nl, Decl(a.js, 35, 3), Decl(b.ts, 11, 3)) + +var A: any[]; +>A : Symbol(A, Decl(a.js, 38, 3), Decl(b.ts, 12, 3)) + +var a: any[]; +>a : Symbol(a, Decl(a.js, 41, 3), Decl(b.ts, 13, 3)) + +var P: Promise; +>P : Symbol(P, Decl(a.js, 44, 3), Decl(b.ts, 14, 3)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --)) + +var p: Promise; +>p : Symbol(p, Decl(a.js, 47, 3), Decl(b.ts, 15, 3)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --)) + +var nullable: number | null; +>nullable : Symbol(nullable, Decl(a.js, 50, 3), Decl(b.ts, 16, 3)) + +var Obj: any; +>Obj : Symbol(Obj, Decl(a.js, 53, 3), Decl(b.ts, 17, 3)) + diff --git a/tests/baselines/reference/jsDocTypes.types b/tests/baselines/reference/jsDocTypes.types new file mode 100644 index 00000000000..c0214edf627 --- /dev/null +++ b/tests/baselines/reference/jsDocTypes.types @@ -0,0 +1,136 @@ +=== tests/cases/conformance/salsa/a.js === + +/** @type {String} */ +var S; +>S : string + +/** @type {string} */ +var s; +>s : string + +/** @type {Number} */ +var N; +>N : number + +/** @type {number} */ +var n; +>n : number + +/** @type {Boolean} */ +var B; +>B : boolean + +/** @type {boolean} */ +var b; +>b : boolean + +/** @type {Void} */ +var V; +>V : void + +/** @type {void} */ +var v; +>v : void + +/** @type {Undefined} */ +var U; +>U : undefined + +/** @type {undefined} */ +var u; +>u : undefined + +/** @type {Null} */ +var Nl; +>Nl : null + +/** @type {null} */ +var nl; +>nl : null + +/** @type {Array} */ +var A; +>A : any[] + +/** @type {array} */ +var a; +>a : any[] + +/** @type {Promise} */ +var P; +>P : Promise + +/** @type {promise} */ +var p; +>p : Promise + +/** @type {?number} */ +var nullable; +>nullable : number | null + +/** @type {Object} */ +var Obj; +>Obj : any + + + +=== tests/cases/conformance/salsa/b.ts === +var S: string; +>S : string + +var s: string; +>s : string + +var N: number; +>N : number + +var n: number +>n : number + +var B: boolean; +>B : boolean + +var b: boolean; +>b : boolean + +var V :void; +>V : void + +var v: void; +>v : void + +var U: undefined; +>U : undefined + +var u: undefined; +>u : undefined + +var Nl: null; +>Nl : null +>null : null + +var nl: null; +>nl : null +>null : null + +var A: any[]; +>A : any[] + +var a: any[]; +>a : any[] + +var P: Promise; +>P : Promise +>Promise : Promise + +var p: Promise; +>p : Promise +>Promise : Promise + +var nullable: number | null; +>nullable : number | null +>null : null + +var Obj: any; +>Obj : any + diff --git a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.types b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.types index c420454b8cf..f40e9164c38 100644 --- a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.types +++ b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.types @@ -11,8 +11,8 @@ * @returns {*} Returns the result of `func`. */ function apply(func, thisArg, args) { ->apply : (func: Function, thisArg: any, ...args: any[]) => any ->func : Function +>apply : (func: {}, thisArg: any, ...args: any[]) => any +>func : {} >thisArg : any >args : any[] @@ -29,7 +29,7 @@ function apply(func, thisArg, args) { >0 : 0 >func.call(thisArg) : any >func.call : (this: Function, thisArg: any, ...argArray: any[]) => any ->func : Function +>func : {} >call : (this: Function, thisArg: any, ...argArray: any[]) => any >thisArg : any @@ -37,7 +37,7 @@ function apply(func, thisArg, args) { >1 : 1 >func.call(thisArg, args[0]) : any >func.call : (this: Function, thisArg: any, ...argArray: any[]) => any ->func : Function +>func : {} >call : (this: Function, thisArg: any, ...argArray: any[]) => any >thisArg : any >args[0] : any @@ -48,7 +48,7 @@ function apply(func, thisArg, args) { >2 : 2 >func.call(thisArg, args[0], args[1]) : any >func.call : (this: Function, thisArg: any, ...argArray: any[]) => any ->func : Function +>func : {} >call : (this: Function, thisArg: any, ...argArray: any[]) => any >thisArg : any >args[0] : any @@ -62,7 +62,7 @@ function apply(func, thisArg, args) { >3 : 3 >func.call(thisArg, args[0], args[1], args[2]) : any >func.call : (this: Function, thisArg: any, ...argArray: any[]) => any ->func : Function +>func : {} >call : (this: Function, thisArg: any, ...argArray: any[]) => any >thisArg : any >args[0] : any @@ -78,12 +78,12 @@ function apply(func, thisArg, args) { return func.apply(thisArg, args); >func.apply(thisArg, args) : any >func.apply : (this: Function, thisArg: any, argArray?: any) => any ->func : Function +>func : {} >apply : (this: Function, thisArg: any, argArray?: any) => any >thisArg : any >args : any[] } export default apply; ->apply : (func: Function, thisArg: any, ...args: any[]) => any +>apply : (func: {}, thisArg: any, ...args: any[]) => any diff --git a/tests/cases/conformance/salsa/jsDocTypes.ts b/tests/cases/conformance/salsa/jsDocTypes.ts new file mode 100644 index 00000000000..9a13c533d0a --- /dev/null +++ b/tests/cases/conformance/salsa/jsDocTypes.ts @@ -0,0 +1,80 @@ +// @allowJS: true +// @suppressOutputPathCheck: true +// @strictNullChecks: true + +// @filename: a.js +/** @type {String} */ +var S; + +/** @type {string} */ +var s; + +/** @type {Number} */ +var N; + +/** @type {number} */ +var n; + +/** @type {Boolean} */ +var B; + +/** @type {boolean} */ +var b; + +/** @type {Void} */ +var V; + +/** @type {void} */ +var v; + +/** @type {Undefined} */ +var U; + +/** @type {undefined} */ +var u; + +/** @type {Null} */ +var Nl; + +/** @type {null} */ +var nl; + +/** @type {Array} */ +var A; + +/** @type {array} */ +var a; + +/** @type {Promise} */ +var P; + +/** @type {promise} */ +var p; + +/** @type {?number} */ +var nullable; + +/** @type {Object} */ +var Obj; + + + +// @filename: b.ts +var S: string; +var s: string; +var N: number; +var n: number +var B: boolean; +var b: boolean; +var V :void; +var v: void; +var U: undefined; +var u: undefined; +var Nl: null; +var nl: null; +var A: any[]; +var a: any[]; +var P: Promise; +var p: Promise; +var nullable: number | null; +var Obj: any; From 82b5655e66e3cc84dc95f96c80176ce7fc71548d Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Fri, 24 Feb 2017 14:22:55 -0800 Subject: [PATCH 15/45] Special prop assignment symbol applies only to lhs In a Javascript file, the binder assigns a SpecialPropertyAssignment marker to the BinaryExpression node of several kinds of special assignments. Then it binds a special symbol whose declaration is that BinaryExpression node. But the symbol only applies to the left-hand side of the assignment. The right-hand side is an independent expression that should have its own symbols. Previously, symbol lookup in the checker didn't check whether a Javascript node that was part of a special property assignment came from the lhs or the rhs. So the right-hand side would also incorrectly get the special symbol intended for the left-hand side. `getSpecialPropertyAssignmentSymbolFromEntityName` in the checker now checks that its argument is the left-hand side of an assignment before returning a special property assignment symbol. --- src/compiler/checker.ts | 4 +++- .../cases/fourslash/renameJsObjectLiteralMethod.ts | 13 +++++++++++++ 2 files changed, 16 insertions(+), 1 deletion(-) create mode 100644 tests/cases/fourslash/renameJsObjectLiteralMethod.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 83fea11c993..b3c2726ba85 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -20898,7 +20898,9 @@ namespace ts { return getSymbolOfNode(entityName.parent); } - if (isInJavaScriptFile(entityName) && entityName.parent.kind === SyntaxKind.PropertyAccessExpression) { + if (isInJavaScriptFile(entityName) && + entityName.parent.kind === SyntaxKind.PropertyAccessExpression && + entityName.parent === (entityName.parent.parent as BinaryExpression).left) { // Check if this is a special property assignment const specialPropertyAssignmentSymbol = getSpecialPropertyAssignmentSymbolFromEntityName(entityName); if (specialPropertyAssignmentSymbol) { diff --git a/tests/cases/fourslash/renameJsObjectLiteralMethod.ts b/tests/cases/fourslash/renameJsObjectLiteralMethod.ts new file mode 100644 index 00000000000..b4b9fb80528 --- /dev/null +++ b/tests/cases/fourslash/renameJsObjectLiteralMethod.ts @@ -0,0 +1,13 @@ +/// +// @allowJs: true +// @Filename: a.js +////const foo = { +//// set: function (x) { +//// this._x = x; +//// }, +//// copy: function ([|x|]) { +//// this._x = /**/[|x|].prop; +//// } +////}; +goTo.marker(); +verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); From 44e1140cf69605bc2c3a60c186b98b0e73a94423 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Fri, 24 Feb 2017 14:53:35 -0800 Subject: [PATCH 16/45] Rename tests --- ...alMethod.ts => renameJsSpecialAssignmentRhs1.ts} | 0 .../fourslash/renameJsSpecialAssignmentRhs2.ts | 13 +++++++++++++ 2 files changed, 13 insertions(+) rename tests/cases/fourslash/{renameJsObjectLiteralMethod.ts => renameJsSpecialAssignmentRhs1.ts} (100%) create mode 100644 tests/cases/fourslash/renameJsSpecialAssignmentRhs2.ts diff --git a/tests/cases/fourslash/renameJsObjectLiteralMethod.ts b/tests/cases/fourslash/renameJsSpecialAssignmentRhs1.ts similarity index 100% rename from tests/cases/fourslash/renameJsObjectLiteralMethod.ts rename to tests/cases/fourslash/renameJsSpecialAssignmentRhs1.ts diff --git a/tests/cases/fourslash/renameJsSpecialAssignmentRhs2.ts b/tests/cases/fourslash/renameJsSpecialAssignmentRhs2.ts new file mode 100644 index 00000000000..5b4b6e851cf --- /dev/null +++ b/tests/cases/fourslash/renameJsSpecialAssignmentRhs2.ts @@ -0,0 +1,13 @@ +/// +// @allowJs: true +// @Filename: a.js +////const foo = { +//// set: function (x) { +//// this._x = x; +//// }, +//// copy: function (/**/[|x|]) { +//// this._x = [|x|].prop; +//// } +////}; +goTo.marker(); +verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); From efcca8ce468d2245faa087e30255cb99f4e89479 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Sat, 25 Feb 2017 13:02:56 -0800 Subject: [PATCH 17/45] Make server target depend on services inputs --- Jakefile.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Jakefile.js b/Jakefile.js index 78516f60731..f8be7c2b671 100644 --- a/Jakefile.js +++ b/Jakefile.js @@ -587,7 +587,7 @@ var watchGuardFile = path.join(builtLocalDirectory, "watchGuard.js"); compileFile(watchGuardFile, watchGuardSources, [builtLocalDirectory].concat(watchGuardSources), /*prefixes*/ [copyright], /*useBuiltCompiler*/ true, { outDir: builtLocalDirectory, noOutFile: false }); var serverFile = path.join(builtLocalDirectory, "tsserver.js"); -compileFile(serverFile, serverSources, [builtLocalDirectory, copyright, cancellationTokenFile, typingsInstallerFile, watchGuardFile].concat(serverSources), /*prefixes*/ [copyright], /*useBuiltCompiler*/ true, { types: ["node"], preserveConstEnums: true }); +compileFile(serverFile, serverSources, [builtLocalDirectory, copyright, cancellationTokenFile, typingsInstallerFile, watchGuardFile].concat(serverSources).concat(servicesSources), /*prefixes*/ [copyright], /*useBuiltCompiler*/ true, { types: ["node"], preserveConstEnums: true }); var tsserverLibraryFile = path.join(builtLocalDirectory, "tsserverlibrary.js"); var tsserverLibraryDefinitionFile = path.join(builtLocalDirectory, "tsserverlibrary.d.ts"); compileFile( From 27675fc96e6da8dbb7d7a328def8a07c1a73e37f Mon Sep 17 00:00:00 2001 From: Oleg Mihailik Date: Sat, 25 Feb 2017 23:35:24 +0000 Subject: [PATCH 18/45] Avoid failing TS2695 for eval. --- src/compiler/checker.ts | 2 +- tests/cases/compiler/evalAfter0.ts | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) create mode 100644 tests/cases/compiler/evalAfter0.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index ac5012a3bf9..15782e13610 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -15929,7 +15929,7 @@ namespace ts { checkAssignmentOperator(rightType); return getRegularTypeOfObjectLiteral(rightType); case SyntaxKind.CommaToken: - if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left)) { + if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && right.text!=="eval") { error(left, Diagnostics.Left_side_of_comma_operator_is_unused_and_has_no_side_effects); } return rightType; diff --git a/tests/cases/compiler/evalAfter0.ts b/tests/cases/compiler/evalAfter0.ts new file mode 100644 index 00000000000..ff9a036faca --- /dev/null +++ b/tests/cases/compiler/evalAfter0.ts @@ -0,0 +1,3 @@ +(0,eval)("10"); + +(0,alert)("10"); \ No newline at end of file From 6a88cf0edf01730cb656cb1e97fad9972c2a4fb2 Mon Sep 17 00:00:00 2001 From: Oleg Mihailik Date: Sun, 26 Feb 2017 23:13:50 +0000 Subject: [PATCH 19/45] Better check for right.text, more comments in test --- src/compiler/checker.ts | 6 +++++- tests/cases/compiler/evalAfter0.ts | 4 ++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 15782e13610..ddb1d371a14 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -15929,12 +15929,16 @@ namespace ts { checkAssignmentOperator(rightType); return getRegularTypeOfObjectLiteral(rightType); case SyntaxKind.CommaToken: - if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && right.text!=="eval") { + if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && !isEvalNode(right)) { error(left, Diagnostics.Left_side_of_comma_operator_is_unused_and_has_no_side_effects); } return rightType; } + function isEvalNode(node: Expression) { + return node.kind === SyntaxKind.Identifier && (node as Identifier).text === "eval"; + } + // Return true if there was no error, false if there was an error. function checkForDisallowedESSymbolOperand(operator: SyntaxKind): boolean { const offendingSymbolOperand = diff --git a/tests/cases/compiler/evalAfter0.ts b/tests/cases/compiler/evalAfter0.ts index ff9a036faca..98c0ea78f7d 100644 --- a/tests/cases/compiler/evalAfter0.ts +++ b/tests/cases/compiler/evalAfter0.ts @@ -1,3 +1,3 @@ -(0,eval)("10"); +(0,eval)("10"); // fine: special case for eval -(0,alert)("10"); \ No newline at end of file +(0,alert)("10"); // error: no side effect left of comma (suspect of missing method name or something) \ No newline at end of file From baef2aa2c17c59669038525e95010581ac273fe1 Mon Sep 17 00:00:00 2001 From: Oleg Mihailik Date: Mon, 27 Feb 2017 01:05:56 +0000 Subject: [PATCH 20/45] Baseline accept --- tests/baselines/reference/evalAfter0.errors.txt | 10 ++++++++++ tests/baselines/reference/evalAfter0.js | 9 +++++++++ tests/cases/compiler/evalAfter0.ts | 3 ++- 3 files changed, 21 insertions(+), 1 deletion(-) create mode 100644 tests/baselines/reference/evalAfter0.errors.txt create mode 100644 tests/baselines/reference/evalAfter0.js diff --git a/tests/baselines/reference/evalAfter0.errors.txt b/tests/baselines/reference/evalAfter0.errors.txt new file mode 100644 index 00000000000..448772eda08 --- /dev/null +++ b/tests/baselines/reference/evalAfter0.errors.txt @@ -0,0 +1,10 @@ +tests/cases/compiler/evalAfter0.ts(4,2): error TS2695: Left side of comma operator is unused and has no side effects. + + +==== tests/cases/compiler/evalAfter0.ts (1 errors) ==== + (0,eval)("10"); // fine: special case for eval + + declare var eva; + (0,eva)("10"); // error: no side effect left of comma (suspect of missing method name or something) + ~ +!!! error TS2695: Left side of comma operator is unused and has no side effects. \ No newline at end of file diff --git a/tests/baselines/reference/evalAfter0.js b/tests/baselines/reference/evalAfter0.js new file mode 100644 index 00000000000..aeaa8f6476c --- /dev/null +++ b/tests/baselines/reference/evalAfter0.js @@ -0,0 +1,9 @@ +//// [evalAfter0.ts] +(0,eval)("10"); // fine: special case for eval + +declare var eva; +(0,eva)("10"); // error: no side effect left of comma (suspect of missing method name or something) + +//// [evalAfter0.js] +(0, eval)("10"); // fine: special case for eval +(0, eva)("10"); // error: no side effect left of comma (suspect of missing method name or something) diff --git a/tests/cases/compiler/evalAfter0.ts b/tests/cases/compiler/evalAfter0.ts index 98c0ea78f7d..2245150ce6a 100644 --- a/tests/cases/compiler/evalAfter0.ts +++ b/tests/cases/compiler/evalAfter0.ts @@ -1,3 +1,4 @@ (0,eval)("10"); // fine: special case for eval -(0,alert)("10"); // error: no side effect left of comma (suspect of missing method name or something) \ No newline at end of file +declare var eva; +(0,eva)("10"); // error: no side effect left of comma (suspect of missing method name or something) \ No newline at end of file From c2f4b202a4e9d4940cc2331dbdd1fafed1bae610 Mon Sep 17 00:00:00 2001 From: andy-ms Date: Sun, 26 Feb 2017 17:47:39 -0800 Subject: [PATCH 21/45] Add more specific return type for `getTypeParameters()` --- src/services/services.ts | 2 +- src/services/types.ts | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index 0c7b5d97d26..f122e39bcc6 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -412,7 +412,7 @@ namespace ts { getDeclaration(): SignatureDeclaration { return this.declaration; } - getTypeParameters(): Type[] { + getTypeParameters(): TypeParameter[] { return this.typeParameters; } getParameters(): Symbol[] { diff --git a/src/services/types.ts b/src/services/types.ts index a577fb20aac..9253153c004 100644 --- a/src/services/types.ts +++ b/src/services/types.ts @@ -39,7 +39,7 @@ namespace ts { export interface Signature { getDeclaration(): SignatureDeclaration; - getTypeParameters(): Type[]; + getTypeParameters(): TypeParameter[]; getParameters(): Symbol[]; getReturnType(): Type; getDocumentationComment(): SymbolDisplayPart[]; From d7461c874b5fa40e166ac4efd1127049a7df0ca8 Mon Sep 17 00:00:00 2001 From: mihailik Date: Mon, 27 Feb 2017 08:39:01 +0000 Subject: [PATCH 22/45] Promise is a duplicate here - fails to build --- Gulpfile.ts | 4 ---- 1 file changed, 4 deletions(-) diff --git a/Gulpfile.ts b/Gulpfile.ts index 7e7f05fd9c4..633a1387ab6 100644 --- a/Gulpfile.ts +++ b/Gulpfile.ts @@ -21,10 +21,6 @@ declare module "gulp-typescript" { import * as insert from "gulp-insert"; import * as sourcemaps from "gulp-sourcemaps"; import Q = require("q"); -declare global { - // `del` further depends on `Promise` (and is also not included), so we just, patch the global scope's Promise to Q's (which we already include in our deps because gulp depends on it) - type Promise = Q.Promise; -} import del = require("del"); import mkdirP = require("mkdirp"); import minimist = require("minimist"); From 8c2bcaedee1ac3d51ec9ce6a9a982d922d889adf Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Mon, 27 Feb 2017 11:43:52 -0800 Subject: [PATCH 23/45] Fix emit for downlevel generated catch variable --- src/compiler/transformers/generators.ts | 27 +++-- .../reference/emitter.forAwait.es5.js | 112 +++++++++--------- 2 files changed, 73 insertions(+), 66 deletions(-) diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts index ff832188b5b..57e85f50f39 100644 --- a/src/compiler/transformers/generators.ts +++ b/src/compiler/transformers/generators.ts @@ -1942,7 +1942,7 @@ namespace ts { } function substituteExpressionIdentifier(node: Identifier) { - if (renamedCatchVariables && renamedCatchVariables.has(node.text)) { + if (!isGeneratedIdentifier(node) && renamedCatchVariables && renamedCatchVariables.has(node.text)) { const original = getOriginalNode(node); if (isIdentifier(original) && original.parent) { const declaration = resolver.getReferencedValueDeclaration(original); @@ -2108,17 +2108,24 @@ namespace ts { function beginCatchBlock(variable: VariableDeclaration): void { Debug.assert(peekBlockKind() === CodeBlockKind.Exception); - const text = (variable.name).text; - const name = declareLocal(text); - - if (!renamedCatchVariables) { - renamedCatchVariables = createMap(); - renamedCatchVariableDeclarations = []; - context.enableSubstitution(SyntaxKind.Identifier); + // generated identifiers should already be unique within a file + let name: Identifier; + if (isGeneratedIdentifier(variable.name)) { + name = variable.name; + hoistVariableDeclaration(variable.name); } + else { + const text = (variable.name).text; + name = declareLocal(text); + if (!renamedCatchVariables) { + renamedCatchVariables = createMap(); + renamedCatchVariableDeclarations = []; + context.enableSubstitution(SyntaxKind.Identifier); + } - renamedCatchVariables.set(text, true); - renamedCatchVariableDeclarations[getOriginalNodeId(variable)] = name; + renamedCatchVariables.set(text, true); + renamedCatchVariableDeclarations[getOriginalNodeId(variable)] = name; + } const exception = peekBlock(); Debug.assert(exception.state < ExceptionBlockState.Catch); diff --git a/tests/baselines/reference/emitter.forAwait.es5.js b/tests/baselines/reference/emitter.forAwait.es5.js index efbbe872b3f..14b70e933bb 100644 --- a/tests/baselines/reference/emitter.forAwait.es5.js +++ b/tests/baselines/reference/emitter.forAwait.es5.js @@ -68,36 +68,36 @@ var __asyncValues = (this && this.__asyncIterator) || function (o) { }; function f1() { return __awaiter(this, void 0, void 0, function () { - var y, y_1, y_1_1, x, _a, e_1, _b; - return __generator(this, function (_c) { - switch (_c.label) { + var y, y_1, y_1_1, x, e_1_1, e_1, _a; + return __generator(this, function (_b) { + switch (_b.label) { case 0: - _c.trys.push([0, 6, 7, 12]); + _b.trys.push([0, 6, 7, 12]); y_1 = __asyncValues(y); return [4 /*yield*/, y_1.next()]; case 1: - y_1_1 = _c.sent(); - _c.label = 2; + y_1_1 = _b.sent(); + _b.label = 2; case 2: if (!!y_1_1.done) return [3 /*break*/, 5]; x = y_1_1.value; - _c.label = 3; + _b.label = 3; case 3: return [4 /*yield*/, y_1.next()]; case 4: - y_1_1 = _c.sent(); + y_1_1 = _b.sent(); return [3 /*break*/, 2]; case 5: return [3 /*break*/, 12]; case 6: - _a = _c.sent(); + e_1_1 = _b.sent(); e_1 = { error: e_1_1 }; return [3 /*break*/, 12]; case 7: - _c.trys.push([7, , 10, 11]); - if (!(y_1_1 && !y_1_1.done && (_b = y_1.return))) return [3 /*break*/, 9]; - return [4 /*yield*/, _b.call(y_1)]; + _b.trys.push([7, , 10, 11]); + if (!(y_1_1 && !y_1_1.done && (_a = y_1.return))) return [3 /*break*/, 9]; + return [4 /*yield*/, _a.call(y_1)]; case 8: - _c.sent(); - _c.label = 9; + _b.sent(); + _b.label = 9; case 9: return [3 /*break*/, 11]; case 10: if (e_1) throw e_1.error; @@ -151,36 +151,36 @@ var __asyncValues = (this && this.__asyncIterator) || function (o) { }; function f2() { return __awaiter(this, void 0, void 0, function () { - var x, y, y_1, y_1_1, _a, e_1, _b; - return __generator(this, function (_c) { - switch (_c.label) { + var x, y, y_1, y_1_1, e_1_1, e_1, _a; + return __generator(this, function (_b) { + switch (_b.label) { case 0: - _c.trys.push([0, 6, 7, 12]); + _b.trys.push([0, 6, 7, 12]); y_1 = __asyncValues(y); return [4 /*yield*/, y_1.next()]; case 1: - y_1_1 = _c.sent(); - _c.label = 2; + y_1_1 = _b.sent(); + _b.label = 2; case 2: if (!!y_1_1.done) return [3 /*break*/, 5]; x = y_1_1.value; - _c.label = 3; + _b.label = 3; case 3: return [4 /*yield*/, y_1.next()]; case 4: - y_1_1 = _c.sent(); + y_1_1 = _b.sent(); return [3 /*break*/, 2]; case 5: return [3 /*break*/, 12]; case 6: - _a = _c.sent(); + e_1_1 = _b.sent(); e_1 = { error: e_1_1 }; return [3 /*break*/, 12]; case 7: - _c.trys.push([7, , 10, 11]); - if (!(y_1_1 && !y_1_1.done && (_b = y_1.return))) return [3 /*break*/, 9]; - return [4 /*yield*/, _b.call(y_1)]; + _b.trys.push([7, , 10, 11]); + if (!(y_1_1 && !y_1_1.done && (_a = y_1.return))) return [3 /*break*/, 9]; + return [4 /*yield*/, _a.call(y_1)]; case 8: - _c.sent(); - _c.label = 9; + _b.sent(); + _b.label = 9; case 9: return [3 /*break*/, 11]; case 10: if (e_1) throw e_1.error; @@ -239,36 +239,36 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar }; function f3() { return __asyncGenerator(this, arguments, function f3_1() { - var y, y_1, y_1_1, x, _a, e_1, _b; - return __generator(this, function (_c) { - switch (_c.label) { + var y, y_1, y_1_1, x, e_1_1, e_1, _a; + return __generator(this, function (_b) { + switch (_b.label) { case 0: - _c.trys.push([0, 6, 7, 12]); + _b.trys.push([0, 6, 7, 12]); y_1 = __asyncValues(y); return [4 /*yield*/, ["await", y_1.next()]]; case 1: - y_1_1 = _c.sent(); - _c.label = 2; + y_1_1 = _b.sent(); + _b.label = 2; case 2: if (!!y_1_1.done) return [3 /*break*/, 5]; x = y_1_1.value; - _c.label = 3; + _b.label = 3; case 3: return [4 /*yield*/, ["await", y_1.next()]]; case 4: - y_1_1 = _c.sent(); + y_1_1 = _b.sent(); return [3 /*break*/, 2]; case 5: return [3 /*break*/, 12]; case 6: - _a = _c.sent(); + e_1_1 = _b.sent(); e_1 = { error: e_1_1 }; return [3 /*break*/, 12]; case 7: - _c.trys.push([7, , 10, 11]); - if (!(y_1_1 && !y_1_1.done && (_b = y_1.return))) return [3 /*break*/, 9]; - return [4 /*yield*/, ["await", _b.call(y_1)]]; + _b.trys.push([7, , 10, 11]); + if (!(y_1_1 && !y_1_1.done && (_a = y_1.return))) return [3 /*break*/, 9]; + return [4 /*yield*/, ["await", _a.call(y_1)]]; case 8: - _c.sent(); - _c.label = 9; + _b.sent(); + _b.label = 9; case 9: return [3 /*break*/, 11]; case 10: if (e_1) throw e_1.error; @@ -327,36 +327,36 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar }; function f4() { return __asyncGenerator(this, arguments, function f4_1() { - var x, y, y_1, y_1_1, _a, e_1, _b; - return __generator(this, function (_c) { - switch (_c.label) { + var x, y, y_1, y_1_1, e_1_1, e_1, _a; + return __generator(this, function (_b) { + switch (_b.label) { case 0: - _c.trys.push([0, 6, 7, 12]); + _b.trys.push([0, 6, 7, 12]); y_1 = __asyncValues(y); return [4 /*yield*/, ["await", y_1.next()]]; case 1: - y_1_1 = _c.sent(); - _c.label = 2; + y_1_1 = _b.sent(); + _b.label = 2; case 2: if (!!y_1_1.done) return [3 /*break*/, 5]; x = y_1_1.value; - _c.label = 3; + _b.label = 3; case 3: return [4 /*yield*/, ["await", y_1.next()]]; case 4: - y_1_1 = _c.sent(); + y_1_1 = _b.sent(); return [3 /*break*/, 2]; case 5: return [3 /*break*/, 12]; case 6: - _a = _c.sent(); + e_1_1 = _b.sent(); e_1 = { error: e_1_1 }; return [3 /*break*/, 12]; case 7: - _c.trys.push([7, , 10, 11]); - if (!(y_1_1 && !y_1_1.done && (_b = y_1.return))) return [3 /*break*/, 9]; - return [4 /*yield*/, ["await", _b.call(y_1)]]; + _b.trys.push([7, , 10, 11]); + if (!(y_1_1 && !y_1_1.done && (_a = y_1.return))) return [3 /*break*/, 9]; + return [4 /*yield*/, ["await", _a.call(y_1)]]; case 8: - _c.sent(); - _c.label = 9; + _b.sent(); + _b.label = 9; case 9: return [3 /*break*/, 11]; case 10: if (e_1) throw e_1.error; From cc4a3a830f1bd789495766db53e55e35c7cc5fd3 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Mon, 27 Feb 2017 14:18:46 -0800 Subject: [PATCH 24/45] Add check for undefined declarations --- src/services/goToDefinition.ts | 4 ++-- tests/cases/fourslash/goToDefinition_untypedModule.ts | 10 ++++++++++ 2 files changed, 12 insertions(+), 2 deletions(-) create mode 100644 tests/cases/fourslash/goToDefinition_untypedModule.ts diff --git a/src/services/goToDefinition.ts b/src/services/goToDefinition.ts index 0ac6c9f7812..2e35d92b96e 100644 --- a/src/services/goToDefinition.ts +++ b/src/services/goToDefinition.ts @@ -198,11 +198,11 @@ namespace ts.GoToDefinition { return false; } - function tryAddSignature(signatureDeclarations: Declaration[], selectConstructors: boolean, symbolKind: string, symbolName: string, containerName: string, result: DefinitionInfo[]) { + function tryAddSignature(signatureDeclarations: Declaration[] | undefined, selectConstructors: boolean, symbolKind: string, symbolName: string, containerName: string, result: DefinitionInfo[]) { const declarations: Declaration[] = []; let definition: Declaration | undefined; - for (const d of signatureDeclarations) { + if (signatureDeclarations) for (const d of signatureDeclarations) { if (selectConstructors ? d.kind === SyntaxKind.Constructor : isSignatureDeclaration(d)) { declarations.push(d); if ((d).body) definition = d; diff --git a/tests/cases/fourslash/goToDefinition_untypedModule.ts b/tests/cases/fourslash/goToDefinition_untypedModule.ts new file mode 100644 index 00000000000..b4571438434 --- /dev/null +++ b/tests/cases/fourslash/goToDefinition_untypedModule.ts @@ -0,0 +1,10 @@ +/// + +// @Filename: /node_modules/foo/index.js +////not read + +// @Filename: /a.ts +////import { f } from "foo"; +/////**/f(); + +verify.goToDefinition("", []); From 2a3800965b13c036789a131477a60fc8fd74d622 Mon Sep 17 00:00:00 2001 From: DLehenbauer Date: Tue, 28 Feb 2017 07:31:01 -0800 Subject: [PATCH 25/45] Fix TypeError when JSDoc.tags is undefined (see #14362) --- src/compiler/utilities.ts | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 66bf693d831..2ab2fc2fc23 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -1554,7 +1554,10 @@ namespace ts { } } else { - result.push(...filter((doc as JSDoc).tags, tag => tag.kind === kind)); + const tags = (doc as JSDoc).tags; + if (tags) { + result.push(...filter(tags, tag => tag.kind === kind)); + } } } return result; From 7afee8c3ab486176e052997c314cf1788362823e Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Tue, 28 Feb 2017 06:09:22 -0800 Subject: [PATCH 26/45] Fix formatting --- src/services/goToDefinition.ts | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/services/goToDefinition.ts b/src/services/goToDefinition.ts index 2e35d92b96e..b732d8a1193 100644 --- a/src/services/goToDefinition.ts +++ b/src/services/goToDefinition.ts @@ -199,10 +199,14 @@ namespace ts.GoToDefinition { } function tryAddSignature(signatureDeclarations: Declaration[] | undefined, selectConstructors: boolean, symbolKind: string, symbolName: string, containerName: string, result: DefinitionInfo[]) { + if (!signatureDeclarations) { + return false; + } + const declarations: Declaration[] = []; let definition: Declaration | undefined; - if (signatureDeclarations) for (const d of signatureDeclarations) { + for (const d of signatureDeclarations) { if (selectConstructors ? d.kind === SyntaxKind.Constructor : isSignatureDeclaration(d)) { declarations.push(d); if ((d).body) definition = d; From 4aac67b4e6ad0e690ce8c4deaf984ca1f74cca14 Mon Sep 17 00:00:00 2001 From: Kanchalai Tanglertsampan Date: Tue, 28 Feb 2017 09:59:17 -0800 Subject: [PATCH 27/45] Remove assertion --- src/compiler/checker.ts | 3 +-- src/compiler/diagnosticMessages.json | 2 +- .../reference/misspelledNewMetaProperty.errors.txt | 7 +++++++ tests/baselines/reference/misspelledNewMetaProperty.js | 5 +++++ tests/cases/compiler/misspelledNewMetaProperty.ts | 1 + 5 files changed, 15 insertions(+), 3 deletions(-) create mode 100644 tests/baselines/reference/misspelledNewMetaProperty.errors.txt create mode 100644 tests/baselines/reference/misspelledNewMetaProperty.js create mode 100644 tests/cases/compiler/misspelledNewMetaProperty.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 17e101fd286..48baef4494c 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -14804,7 +14804,6 @@ namespace ts { function checkMetaProperty(node: MetaProperty) { checkGrammarMetaProperty(node); - Debug.assert(node.keywordToken === SyntaxKind.NewKeyword && node.name.text === "target", "Unrecognized meta-property."); const container = getNewTargetContainer(node); if (!container) { error(node, Diagnostics.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, "new.target"); @@ -23021,7 +23020,7 @@ namespace ts { function checkGrammarMetaProperty(node: MetaProperty) { if (node.keywordToken === SyntaxKind.NewKeyword) { if (node.name.text !== "target") { - return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_0, node.name.text, tokenToString(node.keywordToken), "target"); + return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.text, tokenToString(node.keywordToken), "target"); } } } diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index b9572b2b0f4..75aa5d25f72 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -3269,7 +3269,7 @@ "category": "Error", "code": 17011 }, - "'{0}' is not a valid meta-property for keyword '{1}'. Did you mean '{0}'?": { + "'{0}' is not a valid meta-property for keyword '{1}'. Did you mean '{2}'?": { "category": "Error", "code": 17012 }, diff --git a/tests/baselines/reference/misspelledNewMetaProperty.errors.txt b/tests/baselines/reference/misspelledNewMetaProperty.errors.txt new file mode 100644 index 00000000000..429a40a5b80 --- /dev/null +++ b/tests/baselines/reference/misspelledNewMetaProperty.errors.txt @@ -0,0 +1,7 @@ +tests/cases/compiler/misspelledNewMetaProperty.ts(1,20): error TS17012: 'targ' is not a valid meta-property for keyword 'new'. Did you mean 'target'? + + +==== tests/cases/compiler/misspelledNewMetaProperty.ts (1 errors) ==== + function foo(){new.targ} + ~~~~ +!!! error TS17012: 'targ' is not a valid meta-property for keyword 'new'. Did you mean 'target'? \ No newline at end of file diff --git a/tests/baselines/reference/misspelledNewMetaProperty.js b/tests/baselines/reference/misspelledNewMetaProperty.js new file mode 100644 index 00000000000..964cf91d52c --- /dev/null +++ b/tests/baselines/reference/misspelledNewMetaProperty.js @@ -0,0 +1,5 @@ +//// [misspelledNewMetaProperty.ts] +function foo(){new.targ} + +//// [misspelledNewMetaProperty.js] +function foo() { new.targ; } diff --git a/tests/cases/compiler/misspelledNewMetaProperty.ts b/tests/cases/compiler/misspelledNewMetaProperty.ts new file mode 100644 index 00000000000..8882264478c --- /dev/null +++ b/tests/cases/compiler/misspelledNewMetaProperty.ts @@ -0,0 +1 @@ +function foo(){new.targ} \ No newline at end of file From d6085f75c4f47a034c0fb1e6eb91d65655344c0a Mon Sep 17 00:00:00 2001 From: Kanchalai Tanglertsampan Date: Tue, 28 Feb 2017 15:41:35 -0800 Subject: [PATCH 28/45] Return completions for JsDoc tagname even when there are no "@' sign prefix --- src/services/completions.ts | 38 ++++++++++++++++++++++++++++--------- src/services/jsDoc.ts | 33 ++++++++++++++++++++++---------- 2 files changed, 52 insertions(+), 19 deletions(-) diff --git a/src/services/completions.ts b/src/services/completions.ts index 1bf57d33fdc..4450be7cad6 100644 --- a/src/services/completions.ts +++ b/src/services/completions.ts @@ -16,11 +16,11 @@ namespace ts.Completions { return undefined; } - const { symbols, isGlobalCompletion, isMemberCompletion, isNewIdentifierLocation, location, isJsDocTagName } = completionData; + const { symbols, isGlobalCompletion, isMemberCompletion, isNewIdentifierLocation, location, isJsDocTagName, shouldAppendAtSignBeforeJsDocTagName } = completionData; if (isJsDocTagName) { // If the current position is a jsDoc tag name, only tag names should be provided for completion - return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries: JsDoc.getAllJsDocCompletionEntries() }; + return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries: JsDoc.getAllJsDocCompletionEntries(shouldAppendAtSignBeforeJsDocTagName) }; } const entries: CompletionEntry[] = []; @@ -815,6 +815,12 @@ namespace ts.Completions { const isJavaScriptFile = isSourceFileJavaScript(sourceFile); let isJsDocTagName = false; + // This is for the case when users request completion in JsDoc without "@" + // i.e. + // /** + // * |completion here| + // **/ + let shouldAppendAtSignBeforeJsDocTagName = false; let start = timestamp(); const currentToken = getTokenAtPosition(sourceFile, position); @@ -826,10 +832,24 @@ namespace ts.Completions { log("getCompletionData: Is inside comment: " + (timestamp() - start)); if (insideComment) { - // The current position is next to the '@' sign, when no tag name being provided yet. - // Provide a full list of tag names - if (hasDocComment(sourceFile, position) && sourceFile.text.charCodeAt(position - 1) === CharacterCodes.at) { - isJsDocTagName = true; + if (hasDocComment(sourceFile, position)) { + // The current position is next to the '@' sign, when no tag name being provided yet. + // Provide a full list of tag names + if (sourceFile.text.charCodeAt(position - 1) === CharacterCodes.at) { + isJsDocTagName = true; + } + else { + const lineStart = getLineStartPositionForPosition(position, sourceFile); + shouldAppendAtSignBeforeJsDocTagName = sourceFile.text.substr(lineStart, position).indexOf("@") === -1; + + // This is for the case + // /** + // * |completion here| + // **/ + if (shouldAppendAtSignBeforeJsDocTagName) { + isJsDocTagName = true; + } + } } // Completion should work inside certain JsDoc tags. For example: @@ -854,8 +874,8 @@ namespace ts.Completions { } } - if (isJsDocTagName) { - return { symbols: undefined, isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, location: undefined, isRightOfDot: false, isJsDocTagName }; + if (isJsDocTagName || shouldAppendAtSignBeforeJsDocTagName) { + return { symbols: undefined, isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, location: undefined, isRightOfDot: false, isJsDocTagName, shouldAppendAtSignBeforeJsDocTagName }; } if (!insideJsDocTagExpression) { @@ -983,7 +1003,7 @@ namespace ts.Completions { log("getCompletionData: Semantic work: " + (timestamp() - semanticStart)); - return { symbols, isGlobalCompletion, isMemberCompletion, isNewIdentifierLocation, location, isRightOfDot: (isRightOfDot || isRightOfOpenTag), isJsDocTagName }; + return { symbols, isGlobalCompletion, isMemberCompletion, isNewIdentifierLocation, location, isRightOfDot: (isRightOfDot || isRightOfOpenTag), isJsDocTagName, shouldAppendAtSignBeforeJsDocTagName }; function getTypeScriptMemberSymbols(): void { // Right of dot member completion list diff --git a/src/services/jsDoc.ts b/src/services/jsDoc.ts index 08a51a63e63..40ee276b0fa 100644 --- a/src/services/jsDoc.ts +++ b/src/services/jsDoc.ts @@ -42,7 +42,8 @@ namespace ts.JsDoc { "prop", "version" ]; - let jsDocCompletionEntries: CompletionEntry[]; + let jsDocTagNameCompletionEntries: CompletionEntry[]; + let jsDocTagNameWithAtSignCompletionEntries: CompletionEntry[]; export function getJsDocCommentsFromDeclarations(declarations: Declaration[]) { // Only collect doc comments from duplicate declarations once: @@ -88,15 +89,27 @@ namespace ts.JsDoc { return undefined; } - export function getAllJsDocCompletionEntries(): CompletionEntry[] { - return jsDocCompletionEntries || (jsDocCompletionEntries = ts.map(jsDocTagNames, tagName => { - return { - name: tagName, - kind: ScriptElementKind.keyword, - kindModifiers: "", - sortText: "0", - }; - })); + export function getAllJsDocCompletionEntries(shouldAppendAtSign: boolean): CompletionEntry[] { + if (!shouldAppendAtSign) { + return jsDocTagNameCompletionEntries || (jsDocTagNameCompletionEntries = ts.map(jsDocTagNames, tagName => { + return { + name: tagName, + kind: ScriptElementKind.keyword, + kindModifiers: "", + sortText: "0", + }; + })); + } + else { + return jsDocTagNameWithAtSignCompletionEntries || (jsDocTagNameWithAtSignCompletionEntries = ts.map(jsDocTagNames, tagName => { + return { + name: `@${tagName}`, + kind: ScriptElementKind.keyword, + kindModifiers: "", + sortText: "0" + } + })); + } } /** From 441c5880d75fe40c9d3d0fba75bd6b541a0d8573 Mon Sep 17 00:00:00 2001 From: Kanchalai Tanglertsampan Date: Tue, 28 Feb 2017 15:41:47 -0800 Subject: [PATCH 29/45] Update fourslash tests --- tests/cases/fourslash/completionInJsDoc.ts | 53 +++++++++++++------ .../completionListAtInvalidLocations.ts | 44 +++++++-------- 2 files changed, 57 insertions(+), 40 deletions(-) diff --git a/tests/cases/fourslash/completionInJsDoc.ts b/tests/cases/fourslash/completionInJsDoc.ts index 8ab9dbd0131..5eca52743a4 100644 --- a/tests/cases/fourslash/completionInJsDoc.ts +++ b/tests/cases/fourslash/completionInJsDoc.ts @@ -2,29 +2,39 @@ // @allowJs: true // @Filename: Foo.js -/////** @/*1*/ */ -////var v1; +//// /** @/*1*/ */ +//// var v1; //// -/////** @p/*2*/ */ -////var v2; +//// /** @p/*2*/ */ +//// var v2; //// -/////** @param /*3*/ */ -////var v3; +//// /** @param /*3*/ */ +//// var v3; //// -/////** @param { n/*4*/ } bar */ -////var v4; +//// /** @param { n/*4*/ } bar */ +//// var v4; //// -/////** @type { n/*5*/ } */ -////var v5; +//// /** @type { n/*5*/ } */ +//// var v5; //// -////// @/*6*/ -////var v6; +//// // @/*6*/ +//// var v6; //// -////// @pa/*7*/ -////var v7; +//// // @pa/*7*/ +//// var v7; //// -/////** @return { n/*8*/ } */ -////var v8; +//// /** @return { n/*8*/ } */ +//// var v8; +//// +//// /** /*9*/ */ +//// +//// /** +//// /*10*/ +//// */ +//// +//// /** +//// * /*11*/ +//// */ goTo.marker('1'); verify.completionListContains("constructor"); @@ -55,3 +65,14 @@ verify.completionListIsEmpty(); goTo.marker('8'); verify.completionListContains('number'); +goTo.marker('9'); +verify.completionListCount(40); +verify.completionListContains("@argument"); + +goTo.marker('10'); +verify.completionListCount(40); +verify.completionListContains("@return"); + +goTo.marker('11'); +verify.completionListCount(40); +verify.completionListContains("@argument"); diff --git a/tests/cases/fourslash/completionListAtInvalidLocations.ts b/tests/cases/fourslash/completionListAtInvalidLocations.ts index 0660f0e183b..171f63825f2 100644 --- a/tests/cases/fourslash/completionListAtInvalidLocations.ts +++ b/tests/cases/fourslash/completionListAtInvalidLocations.ts @@ -1,28 +1,24 @@ /// -////var v1 = ''; -////" /*openString1*/ -////var v2 = ''; -////"/*openString2*/ -////var v3 = ''; -////" bar./*openString3*/ -////var v4 = ''; -////// bar./*inComment1*/ -////var v6 = ''; -////// /*inComment2*/ -////var v7 = ''; -/////** /*inComment3*/ -////var v8 = ''; -/////** /*inComment4*/ **/ -////var v9 = ''; -/////* /*inComment5*/ -////var v11 = ''; -//// // /*inComment6*/ -////var v12 = ''; -////type htm/*inTypeAlias*/ -/// -////// /*inComment7*/ -////foo; -////var v10 = /reg/*inRegExp1*/ex/; +//// var v1 = ''; +//// " /*openString1*/ +//// var v2 = ''; +//// "/*openString2*/ +//// var v3 = ''; +//// " bar./*openString3*/ +//// var v4 = ''; +//// // bar./*inComment1*/ +//// var v6 = ''; +//// // /*inComment2*/ +//// var v7 = ''; +//// /* /*inComment3*/ +//// var v11 = ''; +//// // /*inComment4*/ +//// var v12 = ''; +//// type htm/*inTypeAlias*/ +//// +//// // /*inComment5*/ +//// foo; +//// var v10 = /reg/*inRegExp1*/ex/; goTo.eachMarker(() => verify.completionListIsEmpty()); From e74df1e38bbb911998defecb8899acf1a6806a12 Mon Sep 17 00:00:00 2001 From: Kanchalai Tanglertsampan Date: Tue, 28 Feb 2017 15:51:41 -0800 Subject: [PATCH 30/45] Remove unnecessary comment --- src/services/completions.ts | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/services/completions.ts b/src/services/completions.ts index 4450be7cad6..1d446f0aa59 100644 --- a/src/services/completions.ts +++ b/src/services/completions.ts @@ -842,10 +842,6 @@ namespace ts.Completions { const lineStart = getLineStartPositionForPosition(position, sourceFile); shouldAppendAtSignBeforeJsDocTagName = sourceFile.text.substr(lineStart, position).indexOf("@") === -1; - // This is for the case - // /** - // * |completion here| - // **/ if (shouldAppendAtSignBeforeJsDocTagName) { isJsDocTagName = true; } From a5d104c841fcf546e06df04edc021dbe7b93f032 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Fri, 17 Feb 2017 16:47:51 -0800 Subject: [PATCH 31/45] Fix #14136: Make `Object.create` return `any` all the time --- src/lib/es5.d.ts | 2 +- ...signingFromObjectToAnythingElse.errors.txt | 18 ++---- tests/baselines/reference/objectCreate.types | 60 +++++++++---------- tests/baselines/reference/objectCreate2.types | 56 ++++++++--------- 4 files changed, 65 insertions(+), 71 deletions(-) diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index 8f29deb67db..262c2ba21fe 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -140,7 +140,7 @@ interface ObjectConstructor { * Creates an object that has the specified prototype or that has null prototype. * @param o Object to use as a prototype. May be null. */ - create(o: T | null): T | object; + create(o: object | null): any; /** * Creates an object that has the specified prototype, and that optionally contains specified properties. diff --git a/tests/baselines/reference/assigningFromObjectToAnythingElse.errors.txt b/tests/baselines/reference/assigningFromObjectToAnythingElse.errors.txt index 070339e4726..d3395c7ebc9 100644 --- a/tests/baselines/reference/assigningFromObjectToAnythingElse.errors.txt +++ b/tests/baselines/reference/assigningFromObjectToAnythingElse.errors.txt @@ -1,11 +1,8 @@ tests/cases/compiler/assigningFromObjectToAnythingElse.ts(3,1): error TS2322: Type 'Object' is not assignable to type 'RegExp'. The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead? Property 'exec' is missing in type 'Object'. -tests/cases/compiler/assigningFromObjectToAnythingElse.ts(5,5): error TS2322: Type 'object | Object' is not assignable to type 'String'. - Type 'object' is not assignable to type 'String'. - Property 'charAt' is missing in type '{}'. -tests/cases/compiler/assigningFromObjectToAnythingElse.ts(6,5): error TS2322: Type 'object | Number' is not assignable to type 'String'. - Type 'object' is not assignable to type 'String'. +tests/cases/compiler/assigningFromObjectToAnythingElse.ts(5,17): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/assigningFromObjectToAnythingElse.ts(6,17): error TS2346: Supplied parameters do not match any signature of call target. tests/cases/compiler/assigningFromObjectToAnythingElse.ts(8,5): error TS2322: Type 'Object' is not assignable to type 'Error'. The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead? Property 'name' is missing in type 'Object'. @@ -21,14 +18,11 @@ tests/cases/compiler/assigningFromObjectToAnythingElse.ts(8,5): error TS2322: Ty !!! error TS2322: Property 'exec' is missing in type 'Object'. var a: String = Object.create(""); - ~ -!!! error TS2322: Type 'object | Object' is not assignable to type 'String'. -!!! error TS2322: Type 'object' is not assignable to type 'String'. -!!! error TS2322: Property 'charAt' is missing in type '{}'. + ~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. var c: String = Object.create(1); - ~ -!!! error TS2322: Type 'object | Number' is not assignable to type 'String'. -!!! error TS2322: Type 'object' is not assignable to type 'String'. + ~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. var w: Error = new Object(); ~ diff --git a/tests/baselines/reference/objectCreate.types b/tests/baselines/reference/objectCreate.types index 028c98af817..b4e0e72061e 100644 --- a/tests/baselines/reference/objectCreate.types +++ b/tests/baselines/reference/objectCreate.types @@ -7,19 +7,19 @@ declare var union: null | { a: number, b: string }; >b : string var n = Object.create(null); // object ->n : object ->Object.create(null) : object ->Object.create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>n : any +>Object.create(null) : any +>Object.create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >null : null var t = Object.create({ a: 1, b: "" }); // {a: number, b: string } ->t : object | { a: number; b: string; } ->Object.create({ a: 1, b: "" }) : object | { a: number; b: string; } ->Object.create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>t : any +>Object.create({ a: 1, b: "" }) : any +>Object.create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >{ a: 1, b: "" } : { a: number; b: string; } >a : number >1 : 1 @@ -27,45 +27,45 @@ var t = Object.create({ a: 1, b: "" }); // {a: number, b: string } >"" : "" var u = Object.create(union); // object | {a: number, b: string } ->u : object | { a: number; b: string; } ->Object.create(union) : object | { a: number; b: string; } ->Object.create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>u : any +>Object.create(union) : any +>Object.create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >union : { a: number; b: string; } | null var e = Object.create({}); // {} ->e : object | {} ->Object.create({}) : object | {} ->Object.create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>e : any +>Object.create({}) : any +>Object.create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >{} : {} var o = Object.create({}); // object ->o : object ->Object.create({}) : object ->Object.create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>o : any +>Object.create({}) : any +>Object.create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >{} : object >{} : {} var a = Object.create(null, {}); // any >a : any >Object.create(null, {}) : any ->Object.create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>Object.create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >null : null >{} : {} var a = Object.create({ a: 1, b: "" }, {}); >a : any >Object.create({ a: 1, b: "" }, {}) : any ->Object.create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>Object.create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >{ a: 1, b: "" } : { a: number; b: string; } >a : number >1 : 1 @@ -76,27 +76,27 @@ var a = Object.create({ a: 1, b: "" }, {}); var a = Object.create(union, {}); >a : any >Object.create(union, {}) : any ->Object.create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>Object.create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >union : { a: number; b: string; } | null >{} : {} var a = Object.create({}, {}); >a : any >Object.create({}, {}) : any ->Object.create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>Object.create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >{} : {} >{} : {} var a = Object.create({}, {}); >a : any >Object.create({}, {}) : any ->Object.create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>Object.create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T | null): object | T; (o: object | null, properties: PropertyDescriptorMap): any; } +>create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap): any; } >{} : object >{} : {} >{} : {} diff --git a/tests/baselines/reference/objectCreate2.types b/tests/baselines/reference/objectCreate2.types index 1b33723b0c9..3e19c08bfc0 100644 --- a/tests/baselines/reference/objectCreate2.types +++ b/tests/baselines/reference/objectCreate2.types @@ -9,17 +9,17 @@ declare var union: null | { a: number, b: string }; var n = Object.create(null); // any >n : any >Object.create(null) : any ->Object.create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >null : null var t = Object.create({ a: 1, b: "" }); // {a: number, b: string } ->t : object | { a: number; b: string; } ->Object.create({ a: 1, b: "" }) : object | { a: number; b: string; } ->Object.create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>t : any +>Object.create({ a: 1, b: "" }) : any +>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >{ a: 1, b: "" } : { a: number; b: string; } >a : number >1 : 1 @@ -27,45 +27,45 @@ var t = Object.create({ a: 1, b: "" }); // {a: number, b: string } >"" : "" var u = Object.create(union); // {a: number, b: string } ->u : object | { a: number; b: string; } ->Object.create(union) : object | { a: number; b: string; } ->Object.create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>u : any +>Object.create(union) : any +>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >union : { a: number; b: string; } var e = Object.create({}); // {} ->e : object | {} ->Object.create({}) : object | {} ->Object.create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>e : any +>Object.create({}) : any +>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >{} : {} var o = Object.create({}); // object ->o : object ->Object.create({}) : object ->Object.create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>o : any +>Object.create({}) : any +>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >{} : object >{} : {} var a = Object.create(null, {}); // any >a : any >Object.create(null, {}) : any ->Object.create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >null : null >{} : {} var a = Object.create({ a: 1, b: "" }, {}); >a : any >Object.create({ a: 1, b: "" }, {}) : any ->Object.create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >{ a: 1, b: "" } : { a: number; b: string; } >a : number >1 : 1 @@ -76,27 +76,27 @@ var a = Object.create({ a: 1, b: "" }, {}); var a = Object.create(union, {}); >a : any >Object.create(union, {}) : any ->Object.create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >union : { a: number; b: string; } >{} : {} var a = Object.create({}, {}); >a : any >Object.create({}, {}) : any ->Object.create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >{} : {} >{} : {} var a = Object.create({}, {}); >a : any >Object.create({}, {}) : any ->Object.create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >Object : ObjectConstructor ->create : { (o: T): object | T; (o: object, properties: PropertyDescriptorMap): any; } +>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap): any; } >{} : object >{} : {} >{} : {} From a4904935e0b2be0f7f49bc0de89921884b223614 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Fri, 17 Feb 2017 18:01:13 -0800 Subject: [PATCH 32/45] Fix for-await-of emit in async function --- src/compiler/transformers/esnext.ts | 22 ++++++++++++------- ...ter.asyncGenerators.classMethods.es2015.js | 9 ++++++++ ...mitter.asyncGenerators.classMethods.es5.js | 9 ++++++++ ...cGenerators.functionDeclarations.es2015.js | 7 ++++++ ...syncGenerators.functionDeclarations.es5.js | 7 ++++++ ...ncGenerators.functionExpressions.es2015.js | 7 ++++++ ...asyncGenerators.functionExpressions.es5.js | 7 ++++++ ...cGenerators.objectLiteralMethods.es2015.js | 7 ++++++ ...syncGenerators.objectLiteralMethods.es5.js | 7 ++++++ .../reference/emitter.forAwait.es2015.js | 14 ++++++++---- .../reference/emitter.forAwait.es5.js | 18 ++++++++++----- 11 files changed, 96 insertions(+), 18 deletions(-) diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts index 482f37d45f9..971dddd20ea 100644 --- a/src/compiler/transformers/esnext.ts +++ b/src/compiler/transformers/esnext.ts @@ -357,10 +357,12 @@ namespace ts { const values = createAsyncValuesHelper(context, expression, /*location*/ node.expression); const next = createYield( /*asteriskToken*/ undefined, - createArrayLiteral([ - createLiteral("await"), - createCall(createPropertyAccess(iterator, "next" ), /*typeArguments*/ undefined, []) - ]) + enclosingFunctionFlags & FunctionFlags.Generator + ? createArrayLiteral([ + createLiteral("await"), + createCall(createPropertyAccess(iterator, "next" ), /*typeArguments*/ undefined, []) + ]) + : createCall(createPropertyAccess(iterator, "next" ), /*typeArguments*/ undefined, []) ); hoistVariableDeclaration(errorRecord); @@ -431,10 +433,12 @@ namespace ts { createStatement( createYield( /*asteriskToken*/ undefined, - createArrayLiteral([ - createLiteral("await"), - createFunctionCall(returnMethod, iterator, []) - ]) + enclosingFunctionFlags & FunctionFlags.Generator + ? createArrayLiteral([ + createLiteral("await"), + createFunctionCall(returnMethod, iterator, []) + ]) + : createFunctionCall(returnMethod, iterator, []) ) ) ), @@ -872,6 +876,7 @@ namespace ts { scoped: false, text: ` var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -932,6 +937,7 @@ namespace ts { scoped: false, text: ` var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var m = o[Symbol.asyncIterator]; return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js index 2edcfd99e4b..ba4902102b1 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js @@ -62,6 +62,7 @@ class C9 extends B9 { //// [C1.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -81,6 +82,7 @@ class C1 { } //// [C2.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -101,6 +103,7 @@ class C2 { } //// [C3.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -126,6 +129,7 @@ var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -146,6 +150,7 @@ class C4 { } //// [C5.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -171,6 +176,7 @@ class C5 { } //// [C6.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -191,6 +197,7 @@ class C6 { } //// [C7.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -211,6 +218,7 @@ class C7 { } //// [C8.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -233,6 +241,7 @@ class C8 { } //// [C9.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js index 2b296936368..74a65673e5a 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js @@ -89,6 +89,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -141,6 +142,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -199,6 +201,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -262,6 +265,7 @@ var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -330,6 +334,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -410,6 +415,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -468,6 +474,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -520,6 +527,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -585,6 +593,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js index 97df064bbe8..2b0d6db5353 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js @@ -31,6 +31,7 @@ async function * f7() { //// [F1.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -48,6 +49,7 @@ function f1() { } //// [F2.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -66,6 +68,7 @@ function f2() { } //// [F3.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -89,6 +92,7 @@ var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -107,6 +111,7 @@ function f4() { } //// [F5.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -130,6 +135,7 @@ function f5() { } //// [F6.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -148,6 +154,7 @@ function f6() { } //// [F7.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js index 2a1b4393a9b..42098455ed1 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js @@ -58,6 +58,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -105,6 +106,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -158,6 +160,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -216,6 +219,7 @@ var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -279,6 +283,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -354,6 +359,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -407,6 +413,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js index bc64f029289..90f4b70e9bd 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js @@ -31,6 +31,7 @@ const f7 = async function * () { //// [F1.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -48,6 +49,7 @@ const f1 = function () { }; //// [F2.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -66,6 +68,7 @@ const f2 = function () { }; //// [F3.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -89,6 +92,7 @@ var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -107,6 +111,7 @@ const f4 = function () { }; //// [F5.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -130,6 +135,7 @@ const f5 = function () { }; //// [F6.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -148,6 +154,7 @@ const f6 = function () { }; //// [F7.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js index 9593562987b..a6265063fde 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js @@ -58,6 +58,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -105,6 +106,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -158,6 +160,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -216,6 +219,7 @@ var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -279,6 +283,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -354,6 +359,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -407,6 +413,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js index 3d3af24d030..817b3904f02 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js @@ -45,6 +45,7 @@ const o7 = { //// [O1.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -64,6 +65,7 @@ const o1 = { }; //// [O2.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -84,6 +86,7 @@ const o2 = { }; //// [O3.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -109,6 +112,7 @@ var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -129,6 +133,7 @@ const o4 = { }; //// [O5.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -154,6 +159,7 @@ const o5 = { }; //// [O6.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -174,6 +180,7 @@ const o6 = { }; //// [O7.js] var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js index f819945f288..a0839d8258d 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js @@ -72,6 +72,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -121,6 +122,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -176,6 +178,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -236,6 +239,7 @@ var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -301,6 +305,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -378,6 +383,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -433,6 +439,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } diff --git a/tests/baselines/reference/emitter.forAwait.es2015.js b/tests/baselines/reference/emitter.forAwait.es2015.js index bfd44581b82..a76c3e0b545 100644 --- a/tests/baselines/reference/emitter.forAwait.es2015.js +++ b/tests/baselines/reference/emitter.forAwait.es2015.js @@ -35,6 +35,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var m = o[Symbol.asyncIterator]; return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; @@ -42,14 +43,14 @@ function f1() { return __awaiter(this, void 0, void 0, function* () { let y; try { - for (var y_1 = __asyncValues(y), y_1_1 = yield ["await", y_1.next()]; !y_1_1.done; y_1_1 = yield ["await", y_1.next()]) { + for (var y_1 = __asyncValues(y), y_1_1 = yield y_1.next(); !y_1_1.done; y_1_1 = yield y_1.next()) { const x = y_1_1.value; } } catch (e_1_1) { e_1 = { error: e_1_1 }; } finally { try { - if (y_1_1 && !y_1_1.done && (_a = y_1.return)) yield ["await", _a.call(y_1)]; + if (y_1_1 && !y_1_1.done && (_a = y_1.return)) yield _a.call(y_1); } finally { if (e_1) throw e_1.error; } } @@ -66,6 +67,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var m = o[Symbol.asyncIterator]; return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; @@ -73,14 +75,14 @@ function f2() { return __awaiter(this, void 0, void 0, function* () { let x, y; try { - for (var y_1 = __asyncValues(y), y_1_1 = yield ["await", y_1.next()]; !y_1_1.done; y_1_1 = yield ["await", y_1.next()]) { + for (var y_1 = __asyncValues(y), y_1_1 = yield y_1.next(); !y_1_1.done; y_1_1 = yield y_1.next()) { x = y_1_1.value; } } catch (e_1_1) { e_1 = { error: e_1_1 }; } finally { try { - if (y_1_1 && !y_1_1.done && (_a = y_1.return)) yield ["await", _a.call(y_1)]; + if (y_1_1 && !y_1_1.done && (_a = y_1.return)) yield _a.call(y_1); } finally { if (e_1) throw e_1.error; } } @@ -89,10 +91,12 @@ function f2() { } //// [file3.js] var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var m = o[Symbol.asyncIterator]; return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -124,10 +128,12 @@ function f3() { } //// [file4.js] var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var m = o[Symbol.asyncIterator]; return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } diff --git a/tests/baselines/reference/emitter.forAwait.es5.js b/tests/baselines/reference/emitter.forAwait.es5.js index 5b904cf10a7..efbbe872b3f 100644 --- a/tests/baselines/reference/emitter.forAwait.es5.js +++ b/tests/baselines/reference/emitter.forAwait.es5.js @@ -62,6 +62,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var m = o[Symbol.asyncIterator]; return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; @@ -73,7 +74,7 @@ function f1() { case 0: _c.trys.push([0, 6, 7, 12]); y_1 = __asyncValues(y); - return [4 /*yield*/, ["await", y_1.next()]]; + return [4 /*yield*/, y_1.next()]; case 1: y_1_1 = _c.sent(); _c.label = 2; @@ -81,7 +82,7 @@ function f1() { if (!!y_1_1.done) return [3 /*break*/, 5]; x = y_1_1.value; _c.label = 3; - case 3: return [4 /*yield*/, ["await", y_1.next()]]; + case 3: return [4 /*yield*/, y_1.next()]; case 4: y_1_1 = _c.sent(); return [3 /*break*/, 2]; @@ -93,7 +94,7 @@ function f1() { case 7: _c.trys.push([7, , 10, 11]); if (!(y_1_1 && !y_1_1.done && (_b = y_1.return))) return [3 /*break*/, 9]; - return [4 /*yield*/, ["await", _b.call(y_1)]]; + return [4 /*yield*/, _b.call(y_1)]; case 8: _c.sent(); _c.label = 9; @@ -144,6 +145,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var m = o[Symbol.asyncIterator]; return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; @@ -155,7 +157,7 @@ function f2() { case 0: _c.trys.push([0, 6, 7, 12]); y_1 = __asyncValues(y); - return [4 /*yield*/, ["await", y_1.next()]]; + return [4 /*yield*/, y_1.next()]; case 1: y_1_1 = _c.sent(); _c.label = 2; @@ -163,7 +165,7 @@ function f2() { if (!!y_1_1.done) return [3 /*break*/, 5]; x = y_1_1.value; _c.label = 3; - case 3: return [4 /*yield*/, ["await", y_1.next()]]; + case 3: return [4 /*yield*/, y_1.next()]; case 4: y_1_1 = _c.sent(); return [3 /*break*/, 2]; @@ -175,7 +177,7 @@ function f2() { case 7: _c.trys.push([7, , 10, 11]); if (!(y_1_1 && !y_1_1.done && (_b = y_1.return))) return [3 /*break*/, 9]; - return [4 /*yield*/, ["await", _b.call(y_1)]]; + return [4 /*yield*/, _b.call(y_1)]; case 8: _c.sent(); _c.label = 9; @@ -218,10 +220,12 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var m = o[Symbol.asyncIterator]; return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } @@ -304,10 +308,12 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var m = o[Symbol.asyncIterator]; return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), q = [], c, i; return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } From bb86e9e291a9a592af2f2ce43ebbe0eb946b4a18 Mon Sep 17 00:00:00 2001 From: Jason Jarrett Date: Sun, 19 Feb 2017 22:14:39 -0800 Subject: [PATCH 33/45] Update protocol.ts --- src/server/protocol.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/server/protocol.ts b/src/server/protocol.ts index d8faad28b10..c7d27d80d25 100644 --- a/src/server/protocol.ts +++ b/src/server/protocol.ts @@ -820,7 +820,7 @@ namespace ts.server.protocol { * Represents a file in external project. * External project is project whose set of files, compilation options and open\close state * is maintained by the client (i.e. if all this data come from .csproj file in Visual Studio). - * External project will exist even if all files in it are closed and should be closed explicity. + * External project will exist even if all files in it are closed and should be closed explicitly. * If external project includes one or more tsconfig.json/jsconfig.json files then tsserver will * create configured project for every config file but will maintain a link that these projects were created * as a result of opening external project so they should be removed once external project is closed. From a2f61a8041f0e539f656435aaaf956500236fb60 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Tue, 21 Feb 2017 10:27:50 -0800 Subject: [PATCH 34/45] handle the case when conversion of tsconfig.json failed (#14160) --- .../unittests/tsserverProjectSystem.ts | 27 +++++++++++++++++++ src/server/editorServices.ts | 4 +-- 2 files changed, 29 insertions(+), 2 deletions(-) diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index 92ec0b4ee0e..7446cc84deb 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -3035,6 +3035,33 @@ namespace ts.projectSystem { const inferredProject = projectService.inferredProjects[0]; assert.isTrue(inferredProject.containsFile(file1.path)); }); + + it("should be able to handle @types if input file list is empty", () => { + const f = { + path: "/a/app.ts", + content: "let x = 1" + }; + const config = { + path: "/a/tsconfig.json", + content: JSON.stringify({ + compiler: {}, + files: [] + }) + }; + const t1 = { + path: "/a/node_modules/@types/typings/index.d.ts", + content: `export * from "./lib"` + }; + const t2 = { + path: "/a/node_modules/@types/typings/lib.d.ts", + content: `export const x: number` + }; + const host = createServerHost([f, config, t1, t2], { currentDirectory: getDirectoryPath(f.path) }); + const projectService = createProjectService(host); + + projectService.openClientFile(f.path); + projectService.checkNumberOfProjects({ configuredProjects: 1, inferredProjects: 1 }); + }); }); describe("reload", () => { diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts index 36aa3939c83..d0535e2f528 100644 --- a/src/server/editorServices.ts +++ b/src/server/editorServices.ts @@ -948,9 +948,9 @@ namespace ts.server { private openConfigFile(configFileName: NormalizedPath, clientFileName?: string): OpenConfigFileResult { const conversionResult = this.convertConfigFileContentToProjectOptions(configFileName); - const projectOptions = conversionResult.success + const projectOptions: ProjectOptions = conversionResult.success ? conversionResult.projectOptions - : { files: [], compilerOptions: {} }; + : { files: [], compilerOptions: {}, typeAcquisition: { enable: false } }; const project = this.createAndAddConfiguredProject(configFileName, projectOptions, conversionResult.configFileErrors, clientFileName); return { success: conversionResult.success, From c77ea9e9ea85373c324d67d42e0dae2276a28159 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Tue, 21 Feb 2017 13:59:33 -0800 Subject: [PATCH 35/45] ignore request for codefixes with no error codes (#14215) --- src/server/session.ts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/server/session.ts b/src/server/session.ts index 262ba8da1da..f1b373c4a90 100644 --- a/src/server/session.ts +++ b/src/server/session.ts @@ -1412,6 +1412,9 @@ namespace ts.server { } private getCodeFixes(args: protocol.CodeFixRequestArgs, simplifiedResult: boolean): protocol.CodeAction[] | CodeAction[] { + if (args.errorCodes.length === 0) { + return undefined; + } const { file, project } = this.getFileAndProjectWithoutRefreshingInferredProjects(args); const scriptInfo = project.getScriptInfoForNormalizedPath(file); From 5bcbd7aabc8f25a8fbcb68aa8c9b44eaa88561fc Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 22 Feb 2017 16:15:16 -0800 Subject: [PATCH 36/45] instantiate generic this param correctly --- src/compiler/checker.ts | 15 +++++++++++++-- src/compiler/utilities.ts | 8 ++++++++ ...ClassDoesntImplementInheritedAbstractMember.ts | 4 ++-- .../fixClassIncorrectlyImplementsInterface.ts | 4 ++-- src/services/codefixes/helpers.ts | 14 +++----------- .../fourslash/codeFixClassExtendAbstractMethod.ts | 2 ++ .../codeFixClassExtendAbstractMethodThis.ts | 13 +++++++++++++ .../codeFixClassExtendAbstractPropertyThis.ts | 11 +++++++++++ ...plementInterfaceMethodThisAndSelfReference.ts} | 4 ++-- 9 files changed, 56 insertions(+), 19 deletions(-) create mode 100644 tests/cases/fourslash/codeFixClassExtendAbstractMethodThis.ts create mode 100644 tests/cases/fourslash/codeFixClassExtendAbstractPropertyThis.ts rename tests/cases/fourslash/{codeFixClassImplementInterfaceMethodWithParams.ts => codeFixClassImplementInterfaceMethodThisAndSelfReference.ts} (71%) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 12b55aa818b..9698f0cf4f0 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -21106,7 +21106,15 @@ namespace ts { } if (isPartOfTypeNode(node)) { - return getTypeFromTypeNode(node); + let typeFromTypeNode = getTypeFromTypeNode(node); + + if (typeFromTypeNode && isExpressionWithTypeArgumentsInClassImplementsClause(node)) { + const containingClass = getContainingClass(node); + const classType = getTypeOfNode(containingClass) as InterfaceType; + typeFromTypeNode = getTypeWithThisArgument(typeFromTypeNode, classType.thisType); + } + + return typeFromTypeNode; } if (isPartOfExpression(node)) { @@ -21116,7 +21124,10 @@ namespace ts { if (isExpressionWithTypeArgumentsInClassExtendsClause(node)) { // A SyntaxKind.ExpressionWithTypeArguments is considered a type node, except when it occurs in the // extends clause of a class. We handle that case here. - return getBaseTypes(getDeclaredTypeOfSymbol(getSymbolOfNode(node.parent.parent)))[0]; + const classNode = getContainingClass(node); + const classType = getDeclaredTypeOfSymbol(getSymbolOfNode(classNode)) as InterfaceType; classType; + const baseType = getBaseTypes(classType)[0]; baseType; + return baseType && getTypeWithThisArgument(baseType, classType.thisType); } if (isTypeDeclaration(node)) { diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 66bf693d831..9eb76405031 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -3126,6 +3126,14 @@ namespace ts { return tryGetClassExtendingExpressionWithTypeArguments(node) !== undefined; } + export function isExpressionWithTypeArgumentsInClassImplementsClause(node: Node): boolean { + return node.kind === SyntaxKind.ExpressionWithTypeArguments + && node.parent + && (node.parent).token === SyntaxKind.ImplementsKeyword + && node.parent.parent + && isClassLike(node.parent.parent); + } + export function isEntityNameExpression(node: Expression): node is EntityNameExpression { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PropertyAccessExpression && isEntityNameExpression((node).expression); diff --git a/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts b/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts index 22546e55ecc..16edce0a516 100644 --- a/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts +++ b/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts @@ -22,8 +22,8 @@ namespace ts.codefix { const classDecl = token.parent as ClassLikeDeclaration; const startPos = classDecl.members.pos; - const classType = checker.getTypeAtLocation(classDecl) as InterfaceType; - const instantiatedExtendsType = checker.getBaseTypes(classType)[0]; + const extendsNode = getClassExtendsHeritageClauseElement(classDecl); + const instantiatedExtendsType = checker.getTypeAtLocation(extendsNode); // Note that this is ultimately derived from a map indexed by symbol names, // so duplicates cannot occur. diff --git a/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts b/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts index 42488dc2aed..856a57c46b7 100644 --- a/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts +++ b/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts @@ -17,7 +17,7 @@ namespace ts.codefix { } const startPos: number = classDecl.members.pos; - const classType = checker.getTypeAtLocation(classDecl); + const classType = checker.getTypeAtLocation(classDecl) as InterfaceType; const implementedTypeNodes = getClassImplementsHeritageClauseElements(classDecl); const hasNumericIndexSignature = !!checker.getIndexTypeOfType(classType, IndexKind.Number); @@ -25,7 +25,7 @@ namespace ts.codefix { const result: CodeAction[] = []; for (const implementedTypeNode of implementedTypeNodes) { - const implementedType = checker.getTypeFromTypeNode(implementedTypeNode) as InterfaceType; + const implementedType = checker.getTypeAtLocation(implementedTypeNode) as InterfaceType; // Note that this is ultimately derived from a map indexed by symbol names, // so duplicates cannot occur. const implementedTypeSymbols = checker.getPropertiesOfType(implementedType); diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts index 45479e49474..d20fc0129cd 100644 --- a/src/services/codefixes/helpers.ts +++ b/src/services/codefixes/helpers.ts @@ -32,22 +32,14 @@ namespace ts.codefix { const name = declaration.name ? declaration.name.getText() : undefined; const visibility = getVisibilityPrefixWithSpace(getModifierFlags(declaration)); - const typeAtNewDeclaration = checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration); + const type = checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration); switch (declaration.kind) { case SyntaxKind.GetAccessor: case SyntaxKind.SetAccessor: case SyntaxKind.PropertySignature: case SyntaxKind.PropertyDeclaration: - let typeString: string | undefined = undefined; - const typeAtOldDeclaration = checker.getTypeAtLocation(declaration); - if ((typeAtOldDeclaration as TypeParameter).isThisType) { - typeString = "this"; - } - else { - typeString = checker.typeToString(typeAtNewDeclaration, enclosingDeclaration, TypeFormatFlags.None); - } - + const typeString = checker.typeToString(type, enclosingDeclaration, TypeFormatFlags.None); return `${visibility}${name}: ${typeString};${newlineChar}`; case SyntaxKind.MethodSignature: @@ -59,7 +51,7 @@ namespace ts.codefix { // If there is more than one overload but no implementation signature // (eg: an abstract method or interface declaration), there is a 1-1 // correspondence of declarations and signatures. - const signatures = checker.getSignaturesOfType(typeAtNewDeclaration, SignatureKind.Call); + const signatures = checker.getSignaturesOfType(type, SignatureKind.Call); if (!(signatures && signatures.length > 0)) { return ""; } diff --git a/tests/cases/fourslash/codeFixClassExtendAbstractMethod.ts b/tests/cases/fourslash/codeFixClassExtendAbstractMethod.ts index a657dfeb718..344a7ee3f2b 100644 --- a/tests/cases/fourslash/codeFixClassExtendAbstractMethod.ts +++ b/tests/cases/fourslash/codeFixClassExtendAbstractMethod.ts @@ -2,6 +2,7 @@ //// abstract class A { //// abstract f(a: number, b: string): boolean; +//// abstract f(a: number, b: string): this; //// abstract f(a: string, b: number): Function; //// abstract f(a: string): Function; //// } @@ -10,6 +11,7 @@ verify.rangeAfterCodeFix(` f(a: number, b: string): boolean; + f(a: number, b: string): this; f(a: string, b: number): Function; f(a: string): Function; f(a: any, b?: any) { diff --git a/tests/cases/fourslash/codeFixClassExtendAbstractMethodThis.ts b/tests/cases/fourslash/codeFixClassExtendAbstractMethodThis.ts new file mode 100644 index 00000000000..55b3ad4b77e --- /dev/null +++ b/tests/cases/fourslash/codeFixClassExtendAbstractMethodThis.ts @@ -0,0 +1,13 @@ +/// + +//// abstract class A { +//// abstract f(): this; +//// } +//// +//// class C extends A {[| |]} + +verify.rangeAfterCodeFix(` + f(): this { + throw new Error('Method not implemented.'); + } +`); diff --git a/tests/cases/fourslash/codeFixClassExtendAbstractPropertyThis.ts b/tests/cases/fourslash/codeFixClassExtendAbstractPropertyThis.ts new file mode 100644 index 00000000000..de128ca1b79 --- /dev/null +++ b/tests/cases/fourslash/codeFixClassExtendAbstractPropertyThis.ts @@ -0,0 +1,11 @@ +/// + +//// abstract class A { +//// abstract x: this; +//// } +//// +//// class C extends A {[| |]} + +verify.rangeAfterCodeFix(` + x: this; +`); diff --git a/tests/cases/fourslash/codeFixClassImplementInterfaceMethodWithParams.ts b/tests/cases/fourslash/codeFixClassImplementInterfaceMethodThisAndSelfReference.ts similarity index 71% rename from tests/cases/fourslash/codeFixClassImplementInterfaceMethodWithParams.ts rename to tests/cases/fourslash/codeFixClassImplementInterfaceMethodThisAndSelfReference.ts index 0ee842975e0..95cc3476bf1 100644 --- a/tests/cases/fourslash/codeFixClassImplementInterfaceMethodWithParams.ts +++ b/tests/cases/fourslash/codeFixClassImplementInterfaceMethodThisAndSelfReference.ts @@ -1,14 +1,14 @@ /// //// interface I { -//// f(x: number, y: string): I +//// f(x: number, y: this): I //// } //// //// class C implements I {[| //// |]} verify.rangeAfterCodeFix(` -f(x: number,y: string): I { +f(x: number,y: this): I { throw new Error('Method not implemented.'); } `); From c8aa257a3009079c8d9b8147db1efbf3a49f8d6d Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Wed, 1 Mar 2017 07:57:34 -0800 Subject: [PATCH 37/45] Fix gulp-typescript usage now that it is set to latest --- Gulpfile.ts | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Gulpfile.ts b/Gulpfile.ts index 633a1387ab6..3d4bae39a32 100644 --- a/Gulpfile.ts +++ b/Gulpfile.ts @@ -390,7 +390,7 @@ gulp.task(builtLocalCompiler, false, [servicesFile], () => { .pipe(localCompilerProject()) .pipe(prependCopyright()) .pipe(sourcemaps.write(".")) - .pipe(gulp.dest(".")); + .pipe(gulp.dest("src/compiler")); }); gulp.task(servicesFile, false, ["lib", "generate-diagnostics"], () => { @@ -422,7 +422,7 @@ gulp.task(servicesFile, false, ["lib", "generate-diagnostics"], () => { file.path = nodeStandaloneDefinitionsFile; return content.replace(/declare (namespace|module) ts/g, 'declare module "typescript"'); })) - ]).pipe(gulp.dest(".")); + ]).pipe(gulp.dest("src/services")); }); // cancellationToken.js @@ -448,7 +448,7 @@ gulp.task(typingsInstallerJs, false, [servicesFile], () => { .pipe(cancellationTokenProject()) .pipe(prependCopyright()) .pipe(sourcemaps.write(".")) - .pipe(gulp.dest(".")); + .pipe(gulp.dest("src/server/typingsInstaller")); }); const serverFile = path.join(builtLocalDirectory, "tsserver.js"); @@ -461,7 +461,7 @@ gulp.task(serverFile, false, [servicesFile, typingsInstallerJs, cancellationToke .pipe(serverProject()) .pipe(prependCopyright()) .pipe(sourcemaps.write(".")) - .pipe(gulp.dest(".")); + .pipe(gulp.dest("src/server")); }); const tsserverLibraryFile = path.join(builtLocalDirectory, "tsserverlibrary.js"); @@ -556,7 +556,7 @@ gulp.task(run, false, [servicesFile], () => { .pipe(sourcemaps.init()) .pipe(testProject()) .pipe(sourcemaps.write(".", { includeContent: false, sourceRoot: "../../" })) - .pipe(gulp.dest(".")); + .pipe(gulp.dest("src/harness")); }); const internalTests = "internal/"; @@ -778,7 +778,7 @@ gulp.task("browserify", "Runs browserify on run.js to produce a file suitable fo }); })) .pipe(sourcemaps.write(".", { includeContent: false })) - .pipe(gulp.dest(".")); + .pipe(gulp.dest("src/harness")); }); From 9ac2ea722db7db8d17bd200e1563ca20b5d88960 Mon Sep 17 00:00:00 2001 From: Magnus Hiie Date: Wed, 1 Mar 2017 18:48:08 +0200 Subject: [PATCH 38/45] Add insert...Braces Option to Server Protocol Closes #13275 --- lib/protocol.d.ts | 1 + src/server/protocol.ts | 1 + tests/cases/fourslash/fourslash.ts | 1 + 3 files changed, 3 insertions(+) diff --git a/lib/protocol.d.ts b/lib/protocol.d.ts index 2fc15c3a256..e675ba87417 100644 --- a/lib/protocol.d.ts +++ b/lib/protocol.d.ts @@ -1742,6 +1742,7 @@ declare namespace ts.server.protocol { insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean; insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean; insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean; + insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean; insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean; insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean; insertSpaceBeforeFunctionParenthesis?: boolean; diff --git a/src/server/protocol.ts b/src/server/protocol.ts index c7d27d80d25..d054867cd1c 100644 --- a/src/server/protocol.ts +++ b/src/server/protocol.ts @@ -2218,6 +2218,7 @@ namespace ts.server.protocol { insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean; insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean; insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean; + insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean; insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean; insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean; insertSpaceBeforeFunctionParenthesis?: boolean; diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts index 34afb71ec85..ab83752d93b 100644 --- a/tests/cases/fourslash/fourslash.ts +++ b/tests/cases/fourslash/fourslash.ts @@ -92,6 +92,7 @@ declare namespace FourSlashInterface { InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean; InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean; InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: boolean; + InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: boolean; InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: boolean; InsertSpaceAfterTypeAssertion: boolean; PlaceOpenBraceOnNewLineForFunctions: boolean; From 6ad9fe146a9f80028ecc7b8abc9df7faf7d56824 Mon Sep 17 00:00:00 2001 From: Klaus Meinhardt Date: Wed, 1 Mar 2017 18:08:53 +0100 Subject: [PATCH 39/45] Add parent type to ExpressionWithTypeArguments --- src/compiler/types.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 3d93907ae98..bce435a7e6f 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1446,6 +1446,7 @@ export interface ExpressionWithTypeArguments extends TypeNode { kind: SyntaxKind.ExpressionWithTypeArguments; + parent?: HeritageClause; expression: LeftHandSideExpression; typeArguments?: NodeArray; } From 9bef19c54c629e8b4a109706ef8bfa118afd66f9 Mon Sep 17 00:00:00 2001 From: Kanchalai Tanglertsampan Date: Wed, 1 Mar 2017 09:19:47 -0800 Subject: [PATCH 40/45] Fix JsDoc tagname in tests --- tests/cases/fourslash/completionInJsDoc.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/cases/fourslash/completionInJsDoc.ts b/tests/cases/fourslash/completionInJsDoc.ts index 5eca52743a4..cf8a448bf19 100644 --- a/tests/cases/fourslash/completionInJsDoc.ts +++ b/tests/cases/fourslash/completionInJsDoc.ts @@ -71,7 +71,7 @@ verify.completionListContains("@argument"); goTo.marker('10'); verify.completionListCount(40); -verify.completionListContains("@return"); +verify.completionListContains("@returns"); goTo.marker('11'); verify.completionListCount(40); From d878f80f90cc5376ec1f1198055d0e8634cf7f56 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 1 Mar 2017 11:23:49 -0800 Subject: [PATCH 41/45] more rigorous implements-clause check --- src/compiler/utilities.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 9eb76405031..37fb48bef05 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -3126,8 +3126,9 @@ namespace ts { return tryGetClassExtendingExpressionWithTypeArguments(node) !== undefined; } - export function isExpressionWithTypeArgumentsInClassImplementsClause(node: Node): boolean { + export function isExpressionWithTypeArgumentsInClassImplementsClause(node: Node): node is ExpressionWithTypeArguments { return node.kind === SyntaxKind.ExpressionWithTypeArguments + && isEntityNameExpression((node as ExpressionWithTypeArguments).expression) && node.parent && (node.parent).token === SyntaxKind.ImplementsKeyword && node.parent.parent From 0261586d6e4384fbae32ccec76089c6bb1c79f2f Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 1 Mar 2017 11:27:59 -0800 Subject: [PATCH 42/45] cleanup --- src/compiler/checker.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 9698f0cf4f0..d1990d03ac3 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -21125,8 +21125,8 @@ namespace ts { // A SyntaxKind.ExpressionWithTypeArguments is considered a type node, except when it occurs in the // extends clause of a class. We handle that case here. const classNode = getContainingClass(node); - const classType = getDeclaredTypeOfSymbol(getSymbolOfNode(classNode)) as InterfaceType; classType; - const baseType = getBaseTypes(classType)[0]; baseType; + const classType = getDeclaredTypeOfSymbol(getSymbolOfNode(classNode)) as InterfaceType; + const baseType = getBaseTypes(classType)[0]; return baseType && getTypeWithThisArgument(baseType, classType.thisType); } From b5c6221e36c1e4d20300b07ebefcdcab9121b57c Mon Sep 17 00:00:00 2001 From: Kanchalai Tanglertsampan Date: Wed, 1 Mar 2017 17:46:35 -0800 Subject: [PATCH 43/45] Address PR --- src/services/completions.ts | 56 +++++++++++++++++++++++-------------- src/services/jsDoc.ts | 43 ++++++++++++++-------------- 2 files changed, 56 insertions(+), 43 deletions(-) diff --git a/src/services/completions.ts b/src/services/completions.ts index 1d446f0aa59..042312c1240 100644 --- a/src/services/completions.ts +++ b/src/services/completions.ts @@ -16,11 +16,16 @@ namespace ts.Completions { return undefined; } - const { symbols, isGlobalCompletion, isMemberCompletion, isNewIdentifierLocation, location, isJsDocTagName, shouldAppendAtSignBeforeJsDocTagName } = completionData; + const { symbols, isGlobalCompletion, isMemberCompletion, isNewIdentifierLocation, location, requestJsDocTagName, requestJsDocTag } = completionData; - if (isJsDocTagName) { + if (requestJsDocTagName) { // If the current position is a jsDoc tag name, only tag names should be provided for completion - return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries: JsDoc.getAllJsDocCompletionEntries(shouldAppendAtSignBeforeJsDocTagName) }; + return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries: JsDoc.getJSDocTagNameCompletions() }; + } + + if (requestJsDocTag) { + // If the current position is a jsDoc tag, only tags should be provided for completion + return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries: JsDoc.getJSDocTagCompletions() }; } const entries: CompletionEntry[] = []; @@ -54,7 +59,7 @@ namespace ts.Completions { } // Add keywords if this is not a member completion list - if (!isMemberCompletion && !isJsDocTagName) { + if (!isMemberCompletion && !(requestJsDocTag && requestJsDocTagName)) { addRange(entries, keywordCompletions); } @@ -814,13 +819,10 @@ namespace ts.Completions { function getCompletionData(typeChecker: TypeChecker, log: (message: string) => void, sourceFile: SourceFile, position: number) { const isJavaScriptFile = isSourceFileJavaScript(sourceFile); - let isJsDocTagName = false; - // This is for the case when users request completion in JsDoc without "@" - // i.e. - // /** - // * |completion here| - // **/ - let shouldAppendAtSignBeforeJsDocTagName = false; + // JsDoc tag-name is just the name of the JSDoc tagname (exclude "@") + let requestJsDocTagName = false; + // JsDoc tag includes both "@" and tag-name + let requestJsDocTag = false; let start = timestamp(); const currentToken = getTokenAtPosition(sourceFile, position); @@ -836,15 +838,27 @@ namespace ts.Completions { // The current position is next to the '@' sign, when no tag name being provided yet. // Provide a full list of tag names if (sourceFile.text.charCodeAt(position - 1) === CharacterCodes.at) { - isJsDocTagName = true; + requestJsDocTagName = true; } else { + // When completion is requested without "@", we will have check to make sure that + // there are no comments prefix the request position. We will only allow "*" and space. + // e.g + // /** |c| /* + // + // /** + // |c| + // */ + // + // /** + // * |c| + // */ + // + // /** + // * |c| + // */ const lineStart = getLineStartPositionForPosition(position, sourceFile); - shouldAppendAtSignBeforeJsDocTagName = sourceFile.text.substr(lineStart, position).indexOf("@") === -1; - - if (shouldAppendAtSignBeforeJsDocTagName) { - isJsDocTagName = true; - } + requestJsDocTag = !(sourceFile.text.substr(lineStart, position).match(/[^\*|\s|(/\*\*)]/)); } } @@ -855,7 +869,7 @@ namespace ts.Completions { const tag = getJsDocTagAtPosition(sourceFile, position); if (tag) { if (tag.tagName.pos <= position && position <= tag.tagName.end) { - isJsDocTagName = true; + requestJsDocTagName = true; } switch (tag.kind) { @@ -870,8 +884,8 @@ namespace ts.Completions { } } - if (isJsDocTagName || shouldAppendAtSignBeforeJsDocTagName) { - return { symbols: undefined, isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, location: undefined, isRightOfDot: false, isJsDocTagName, shouldAppendAtSignBeforeJsDocTagName }; + if (requestJsDocTagName || requestJsDocTag) { + return { symbols: undefined, isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, location: undefined, isRightOfDot: false, requestJsDocTagName, requestJsDocTag }; } if (!insideJsDocTagExpression) { @@ -999,7 +1013,7 @@ namespace ts.Completions { log("getCompletionData: Semantic work: " + (timestamp() - semanticStart)); - return { symbols, isGlobalCompletion, isMemberCompletion, isNewIdentifierLocation, location, isRightOfDot: (isRightOfDot || isRightOfOpenTag), isJsDocTagName, shouldAppendAtSignBeforeJsDocTagName }; + return { symbols, isGlobalCompletion, isMemberCompletion, isNewIdentifierLocation, location, isRightOfDot: (isRightOfDot || isRightOfOpenTag), requestJsDocTagName, requestJsDocTag }; function getTypeScriptMemberSymbols(): void { // Right of dot member completion list diff --git a/src/services/jsDoc.ts b/src/services/jsDoc.ts index 40ee276b0fa..59c6ad4b03b 100644 --- a/src/services/jsDoc.ts +++ b/src/services/jsDoc.ts @@ -43,7 +43,7 @@ namespace ts.JsDoc { "version" ]; let jsDocTagNameCompletionEntries: CompletionEntry[]; - let jsDocTagNameWithAtSignCompletionEntries: CompletionEntry[]; + let jsDocTagCompletionEntries: CompletionEntry[]; export function getJsDocCommentsFromDeclarations(declarations: Declaration[]) { // Only collect doc comments from duplicate declarations once: @@ -89,27 +89,26 @@ namespace ts.JsDoc { return undefined; } - export function getAllJsDocCompletionEntries(shouldAppendAtSign: boolean): CompletionEntry[] { - if (!shouldAppendAtSign) { - return jsDocTagNameCompletionEntries || (jsDocTagNameCompletionEntries = ts.map(jsDocTagNames, tagName => { - return { - name: tagName, - kind: ScriptElementKind.keyword, - kindModifiers: "", - sortText: "0", - }; - })); - } - else { - return jsDocTagNameWithAtSignCompletionEntries || (jsDocTagNameWithAtSignCompletionEntries = ts.map(jsDocTagNames, tagName => { - return { - name: `@${tagName}`, - kind: ScriptElementKind.keyword, - kindModifiers: "", - sortText: "0" - } - })); - } + export function getJSDocTagNameCompletions(): CompletionEntry[] { + return jsDocTagNameCompletionEntries || (jsDocTagNameCompletionEntries = ts.map(jsDocTagNames, tagName => { + return { + name: tagName, + kind: ScriptElementKind.keyword, + kindModifiers: "", + sortText: "0", + }; + })); + } + + export function getJSDocTagCompletions(): CompletionEntry[] { + return jsDocTagCompletionEntries || (jsDocTagCompletionEntries = ts.map(jsDocTagNames, tagName => { + return { + name: `@${tagName}`, + kind: ScriptElementKind.keyword, + kindModifiers: "", + sortText: "0" + } + })); } /** From 34b68095d213ed14a718afbb3074f73576d70189 Mon Sep 17 00:00:00 2001 From: Kanchalai Tanglertsampan Date: Wed, 1 Mar 2017 17:46:46 -0800 Subject: [PATCH 44/45] Add more tests --- tests/cases/fourslash/completionInJsDoc.ts | 30 ++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/tests/cases/fourslash/completionInJsDoc.ts b/tests/cases/fourslash/completionInJsDoc.ts index cf8a448bf19..3fd92f42d52 100644 --- a/tests/cases/fourslash/completionInJsDoc.ts +++ b/tests/cases/fourslash/completionInJsDoc.ts @@ -36,6 +36,22 @@ //// * /*11*/ //// */ +//// /** +//// /*12*/ +//// */ + +//// /** +//// * /*13*/ +//// */ + +//// /** +//// * some comment /*14*/ +//// */ + +//// /** +//// * @param /*15*/ +//// */ + goTo.marker('1'); verify.completionListContains("constructor"); verify.completionListContains("param"); @@ -76,3 +92,17 @@ verify.completionListContains("@returns"); goTo.marker('11'); verify.completionListCount(40); verify.completionListContains("@argument"); + +goTo.marker('12'); +verify.completionListCount(40); +verify.completionListContains("@constructor"); + +goTo.marker('13'); +verify.completionListCount(40); +verify.completionListContains("@param"); + +goTo.marker('14'); +verify.completionListIsEmpty(); + +goTo.marker('15'); +verify.completionListIsEmpty(); \ No newline at end of file From da51f396955ffa416e37e985fc33f4cf35aebfe6 Mon Sep 17 00:00:00 2001 From: Yui T Date: Wed, 1 Mar 2017 21:11:34 -0800 Subject: [PATCH 45/45] FIx minor stuffs --- src/services/completions.ts | 4 ++-- tests/cases/fourslash/completionInJsDoc.ts | 13 +++++++++---- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/src/services/completions.ts b/src/services/completions.ts index 042312c1240..6a4ee3485de 100644 --- a/src/services/completions.ts +++ b/src/services/completions.ts @@ -59,7 +59,7 @@ namespace ts.Completions { } // Add keywords if this is not a member completion list - if (!isMemberCompletion && !(requestJsDocTag && requestJsDocTagName)) { + if (!isMemberCompletion && !requestJsDocTag && !requestJsDocTagName) { addRange(entries, keywordCompletions); } @@ -858,7 +858,7 @@ namespace ts.Completions { // * |c| // */ const lineStart = getLineStartPositionForPosition(position, sourceFile); - requestJsDocTag = !(sourceFile.text.substr(lineStart, position).match(/[^\*|\s|(/\*\*)]/)); + requestJsDocTag = !(sourceFile.text.substring(lineStart, position).match(/[^\*|\s|(/\*\*)]/)); } } diff --git a/tests/cases/fourslash/completionInJsDoc.ts b/tests/cases/fourslash/completionInJsDoc.ts index 3fd92f42d52..60707905956 100644 --- a/tests/cases/fourslash/completionInJsDoc.ts +++ b/tests/cases/fourslash/completionInJsDoc.ts @@ -35,22 +35,24 @@ //// /** //// * /*11*/ //// */ - +//// //// /** //// /*12*/ //// */ - +//// //// /** //// * /*13*/ //// */ - +//// //// /** //// * some comment /*14*/ //// */ - +//// //// /** //// * @param /*15*/ //// */ +//// +//// /** @param /*16*/ */ goTo.marker('1'); verify.completionListContains("constructor"); @@ -105,4 +107,7 @@ goTo.marker('14'); verify.completionListIsEmpty(); goTo.marker('15'); +verify.completionListIsEmpty(); + +goTo.marker('16'); verify.completionListIsEmpty(); \ No newline at end of file