From cb63d461dd8bdc985c17b69dc0f786069176bdc1 Mon Sep 17 00:00:00 2001 From: TypeScript Bot Date: Fri, 19 Aug 2022 06:07:20 +0000 Subject: [PATCH 01/16] Update package-lock.json --- package-lock.json | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/package-lock.json b/package-lock.json index 62bca118b3cfb..9eac430388dda 100644 --- a/package-lock.json +++ b/package-lock.json @@ -336,9 +336,9 @@ } }, "node_modules/@octokit/openapi-types": { - "version": "13.1.0", - "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-13.1.0.tgz", - "integrity": "sha512-Z7vzLqfTkoVQyoy/2iQla1N2I4Vav2wi4JbZK8QxIYAfBimhuflosFxmsqw5LTH7DkdNW46ZYpAcqJf0XaS8SQ==", + "version": "13.2.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-13.2.0.tgz", + "integrity": "sha512-1BhjsVrCe2cyE36Rorpeq331bcYzdb9ksCpkFdAN6RVtW67YdO3Pl4YXDC5dF2D1ia76MssJdn5RV+Gj9Fu7dQ==", "dev": true }, "node_modules/@octokit/plugin-paginate-rest": { @@ -8814,9 +8814,9 @@ } }, "@octokit/openapi-types": { - "version": "13.1.0", - "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-13.1.0.tgz", - "integrity": "sha512-Z7vzLqfTkoVQyoy/2iQla1N2I4Vav2wi4JbZK8QxIYAfBimhuflosFxmsqw5LTH7DkdNW46ZYpAcqJf0XaS8SQ==", + "version": "13.2.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-13.2.0.tgz", + "integrity": "sha512-1BhjsVrCe2cyE36Rorpeq331bcYzdb9ksCpkFdAN6RVtW67YdO3Pl4YXDC5dF2D1ia76MssJdn5RV+Gj9Fu7dQ==", "dev": true }, "@octokit/plugin-paginate-rest": { From 05d7d6bb121ad743175c200dcac0de0cd5db550a Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Fri, 19 Aug 2022 02:25:41 -0700 Subject: [PATCH 02/16] Unify default import resolution across specifier target codepaths (#49814) * Unify default import resolution across specifier target codepaths * Use differing type aliases, per request --- src/compiler/checker.ts | 164 +++++++++++------- .../esModuleInteropDefaultImports.errors.txt | 67 +++++++ .../esModuleInteropDefaultImports.js | 103 +++++++++++ .../esModuleInteropDefaultImports.symbols | 121 +++++++++++++ .../esModuleInteropDefaultImports.types | 138 +++++++++++++++ ...deDefaultImports(module=node16).errors.txt | 64 +++++++ ...moduleNodeDefaultImports(module=node16).js | 65 +++++++ ...eNodeDefaultImports(module=node16).symbols | 114 ++++++++++++ ...uleNodeDefaultImports(module=node16).types | 131 ++++++++++++++ ...DefaultImports(module=nodenext).errors.txt | 64 +++++++ ...duleNodeDefaultImports(module=nodenext).js | 65 +++++++ ...odeDefaultImports(module=nodenext).symbols | 114 ++++++++++++ ...eNodeDefaultImports(module=nodenext).types | 131 ++++++++++++++ .../compiler/esModuleInteropDefaultImports.ts | 36 ++++ .../compiler/moduleNodeDefaultImports.ts | 33 ++++ 15 files changed, 1348 insertions(+), 62 deletions(-) create mode 100644 tests/baselines/reference/esModuleInteropDefaultImports.errors.txt create mode 100644 tests/baselines/reference/esModuleInteropDefaultImports.js create mode 100644 tests/baselines/reference/esModuleInteropDefaultImports.symbols create mode 100644 tests/baselines/reference/esModuleInteropDefaultImports.types create mode 100644 tests/baselines/reference/moduleNodeDefaultImports(module=node16).errors.txt create mode 100644 tests/baselines/reference/moduleNodeDefaultImports(module=node16).js create mode 100644 tests/baselines/reference/moduleNodeDefaultImports(module=node16).symbols create mode 100644 tests/baselines/reference/moduleNodeDefaultImports(module=node16).types create mode 100644 tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).errors.txt create mode 100644 tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).js create mode 100644 tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).symbols create mode 100644 tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).types create mode 100644 tests/cases/compiler/esModuleInteropDefaultImports.ts create mode 100644 tests/cases/compiler/moduleNodeDefaultImports.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 8d53b7d1c4eb5..8c8101e87374c 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -2798,44 +2798,66 @@ namespace ts { function getTargetOfImportClause(node: ImportClause, dontResolveAlias: boolean): Symbol | undefined { const moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier); if (moduleSymbol) { - let exportDefaultSymbol: Symbol | undefined; - if (isShorthandAmbientModuleSymbol(moduleSymbol)) { - exportDefaultSymbol = moduleSymbol; - } - else { - exportDefaultSymbol = resolveExportByName(moduleSymbol, InternalSymbolName.Default, node, dontResolveAlias); - } - - const file = moduleSymbol.declarations?.find(isSourceFile); - const hasDefaultOnly = isOnlyImportedAsDefault(node.parent.moduleSpecifier); - const hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, node.parent.moduleSpecifier); - if (!exportDefaultSymbol && !hasSyntheticDefault && !hasDefaultOnly) { - if (hasExportAssignmentSymbol(moduleSymbol)) { - const compilerOptionName = moduleKind >= ModuleKind.ES2015 ? "allowSyntheticDefaultImports" : "esModuleInterop"; - const exportEqualsSymbol = moduleSymbol.exports!.get(InternalSymbolName.ExportEquals); - const exportAssignment = exportEqualsSymbol!.valueDeclaration; - const err = error(node.name, Diagnostics.Module_0_can_only_be_default_imported_using_the_1_flag, symbolToString(moduleSymbol), compilerOptionName); - - if (exportAssignment) { - addRelatedInfo(err, createDiagnosticForNode( - exportAssignment, - Diagnostics.This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag, - compilerOptionName - )); - } - } - else { - reportNonDefaultExport(moduleSymbol, node); + return getTargetofModuleDefault(moduleSymbol, node, dontResolveAlias); + } + } + + function getTargetofModuleDefault(moduleSymbol: Symbol, node: ImportClause | ImportOrExportSpecifier, dontResolveAlias: boolean) { + let exportDefaultSymbol: Symbol | undefined; + if (isShorthandAmbientModuleSymbol(moduleSymbol)) { + exportDefaultSymbol = moduleSymbol; + } + else { + exportDefaultSymbol = resolveExportByName(moduleSymbol, InternalSymbolName.Default, node, dontResolveAlias); + } + + const file = moduleSymbol.declarations?.find(isSourceFile); + const specifier = getModuleSpecifierForImportOrExport(node); + if (!specifier) { + return exportDefaultSymbol; + } + const hasDefaultOnly = isOnlyImportedAsDefault(specifier); + const hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, specifier); + if (!exportDefaultSymbol && !hasSyntheticDefault && !hasDefaultOnly) { + if (hasExportAssignmentSymbol(moduleSymbol)) { + const compilerOptionName = moduleKind >= ModuleKind.ES2015 ? "allowSyntheticDefaultImports" : "esModuleInterop"; + const exportEqualsSymbol = moduleSymbol.exports!.get(InternalSymbolName.ExportEquals); + const exportAssignment = exportEqualsSymbol!.valueDeclaration; + const err = error(node.name, Diagnostics.Module_0_can_only_be_default_imported_using_the_1_flag, symbolToString(moduleSymbol), compilerOptionName); + + if (exportAssignment) { + addRelatedInfo(err, createDiagnosticForNode( + exportAssignment, + Diagnostics.This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag, + compilerOptionName + )); } } - else if (hasSyntheticDefault || hasDefaultOnly) { - // per emit behavior, a synthetic default overrides a "real" .default member if `__esModule` is not present - const resolved = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias); - markSymbolOfAliasDeclarationIfTypeOnly(node, moduleSymbol, resolved, /*overwriteTypeOnly*/ false); - return resolved; + else if (isImportClause(node)) { + reportNonDefaultExport(moduleSymbol, node); } - markSymbolOfAliasDeclarationIfTypeOnly(node, exportDefaultSymbol, /*finalTarget*/ undefined, /*overwriteTypeOnly*/ false); - return exportDefaultSymbol; + else { + errorNoModuleMemberSymbol(moduleSymbol, moduleSymbol, node, isImportOrExportSpecifier(node) && node.propertyName || node.name); + } + } + else if (hasSyntheticDefault || hasDefaultOnly) { + // per emit behavior, a synthetic default overrides a "real" .default member if `__esModule` is not present + const resolved = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(node, moduleSymbol, resolved, /*overwriteTypeOnly*/ false); + return resolved; + } + markSymbolOfAliasDeclarationIfTypeOnly(node, exportDefaultSymbol, /*finalTarget*/ undefined, /*overwriteTypeOnly*/ false); + return exportDefaultSymbol; + } + + function getModuleSpecifierForImportOrExport(node: ImportEqualsDeclaration | ImportClause | NamespaceImport | ImportOrExportSpecifier): Expression | undefined { + switch (node.kind) { + case SyntaxKind.ImportClause: return node.parent.moduleSpecifier; + case SyntaxKind.ImportEqualsDeclaration: return isExternalModuleReference(node.moduleReference) ? node.moduleReference.expression : undefined; + case SyntaxKind.NamespaceImport: return node.parent.parent.moduleSpecifier; + case SyntaxKind.ImportSpecifier: return node.parent.parent.parent.moduleSpecifier; + case SyntaxKind.ExportSpecifier: return node.parent.parent.moduleSpecifier; + default: return Debug.assertNever(node); } } @@ -2969,38 +2991,42 @@ namespace ts { combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) : symbolFromModule || symbolFromVariable; if (!symbol) { - const moduleName = getFullyQualifiedName(moduleSymbol, node); - const declarationName = declarationNameToString(name); - const suggestion = getSuggestedSymbolForNonexistentModule(name, targetSymbol); - if (suggestion !== undefined) { - const suggestionName = symbolToString(suggestion); - const diagnostic = error(name, Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2, moduleName, declarationName, suggestionName); - if (suggestion.valueDeclaration) { - addRelatedInfo(diagnostic, - createDiagnosticForNode(suggestion.valueDeclaration, Diagnostics._0_is_declared_here, suggestionName) - ); - } - } - else { - if (moduleSymbol.exports?.has(InternalSymbolName.Default)) { - error( - name, - Diagnostics.Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead, - moduleName, - declarationName - ); - } - else { - reportNonExportedMember(node, name, declarationName, moduleSymbol, moduleName); - } - } + errorNoModuleMemberSymbol(moduleSymbol, targetSymbol, node, name); } return symbol; } } } - function reportNonExportedMember(node: ImportDeclaration | ExportDeclaration | VariableDeclaration, name: Identifier, declarationName: string, moduleSymbol: Symbol, moduleName: string): void { + function errorNoModuleMemberSymbol(moduleSymbol: Symbol, targetSymbol: Symbol, node: Node, name: Identifier) { + const moduleName = getFullyQualifiedName(moduleSymbol, node); + const declarationName = declarationNameToString(name); + const suggestion = getSuggestedSymbolForNonexistentModule(name, targetSymbol); + if (suggestion !== undefined) { + const suggestionName = symbolToString(suggestion); + const diagnostic = error(name, Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2, moduleName, declarationName, suggestionName); + if (suggestion.valueDeclaration) { + addRelatedInfo(diagnostic, + createDiagnosticForNode(suggestion.valueDeclaration, Diagnostics._0_is_declared_here, suggestionName) + ); + } + } + else { + if (moduleSymbol.exports?.has(InternalSymbolName.Default)) { + error( + name, + Diagnostics.Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead, + moduleName, + declarationName + ); + } + else { + reportNonExportedMember(node, name, declarationName, moduleSymbol, moduleName); + } + } + } + + function reportNonExportedMember(node: Node, name: Identifier, declarationName: string, moduleSymbol: Symbol, moduleName: string): void { const localSymbol = moduleSymbol.valueDeclaration?.locals?.get(name.escapedText); const exports = moduleSymbol.exports; if (localSymbol) { @@ -3025,7 +3051,7 @@ namespace ts { } } - function reportInvalidImportEqualsExportMember(node: ImportDeclaration | ExportDeclaration | VariableDeclaration, name: Identifier, declarationName: string, moduleName: string) { + function reportInvalidImportEqualsExportMember(node: Node, name: Identifier, declarationName: string, moduleName: string) { if (moduleKind >= ModuleKind.ES2015) { const message = getESModuleInterop(compilerOptions) ? Diagnostics._0_can_only_be_imported_by_using_a_default_import : Diagnostics._0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import; @@ -3046,6 +3072,13 @@ namespace ts { } function getTargetOfImportSpecifier(node: ImportSpecifier | BindingElement, dontResolveAlias: boolean): Symbol | undefined { + if (isImportSpecifier(node) && idText(node.propertyName || node.name) === InternalSymbolName.Default) { + const specifier = getModuleSpecifierForImportOrExport(node); + const moduleSymbol = specifier && resolveExternalModuleName(node, specifier); + if (moduleSymbol) { + return getTargetofModuleDefault(moduleSymbol, node, dontResolveAlias); + } + } const root = isBindingElement(node) ? getRootDeclaration(node) as VariableDeclaration : node.parent.parent.parent; const commonJSPropertyAccess = getCommonJSPropertyAccess(root); const resolved = getExternalModuleMember(root, commonJSPropertyAccess || node, dontResolveAlias); @@ -3070,6 +3103,13 @@ namespace ts { } function getTargetOfExportSpecifier(node: ExportSpecifier, meaning: SymbolFlags, dontResolveAlias?: boolean) { + if (idText(node.propertyName || node.name) === InternalSymbolName.Default) { + const specifier = getModuleSpecifierForImportOrExport(node); + const moduleSymbol = specifier && resolveExternalModuleName(node, specifier); + if (moduleSymbol) { + return getTargetofModuleDefault(moduleSymbol, node, !!dontResolveAlias); + } + } const resolved = node.parent.parent.moduleSpecifier ? getExternalModuleMember(node.parent.parent, node, dontResolveAlias) : resolveEntityName(node.propertyName || node.name, meaning, /*ignoreErrors*/ false, dontResolveAlias); diff --git a/tests/baselines/reference/esModuleInteropDefaultImports.errors.txt b/tests/baselines/reference/esModuleInteropDefaultImports.errors.txt new file mode 100644 index 0000000000000..f91da0382ed37 --- /dev/null +++ b/tests/baselines/reference/esModuleInteropDefaultImports.errors.txt @@ -0,0 +1,67 @@ +tests/cases/compiler/b.ts(15,1): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.ts(16,1): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.ts(17,1): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.ts(18,1): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.ts(19,6): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.ts(20,6): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + + +==== tests/cases/compiler/mod.ts (0 errors) ==== + declare function fun(): void; + export default fun; +==== tests/cases/compiler/a.ts (0 errors) ==== + import mod = require("./mod"); + export = mod; +==== tests/cases/compiler/b.ts (6 errors) ==== + import a from "./a"; + import { default as b } from "./a"; + import c, { default as d } from "./a"; + import * as self from "./b"; + export { default } from "./a"; + export { default as def } from "./a"; + + a === b; + b === c; + c === d; + d === self.default; + self.default === self.def; + + // should all fail + a(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + b(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + c(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + d(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + self.default(); + ~~~~~~~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + self.def(); + ~~~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + + // should all work + a.default(); + b.default(); + c.default(); + d.default(); + self.default.default(); + self.def.default(); \ No newline at end of file diff --git a/tests/baselines/reference/esModuleInteropDefaultImports.js b/tests/baselines/reference/esModuleInteropDefaultImports.js new file mode 100644 index 0000000000000..f893e0e968b99 --- /dev/null +++ b/tests/baselines/reference/esModuleInteropDefaultImports.js @@ -0,0 +1,103 @@ +//// [tests/cases/compiler/esModuleInteropDefaultImports.ts] //// + +//// [mod.ts] +declare function fun(): void; +export default fun; +//// [a.ts] +import mod = require("./mod"); +export = mod; +//// [b.ts] +import a from "./a"; +import { default as b } from "./a"; +import c, { default as d } from "./a"; +import * as self from "./b"; +export { default } from "./a"; +export { default as def } from "./a"; + +a === b; +b === c; +c === d; +d === self.default; +self.default === self.def; + +// should all fail +a(); +b(); +c(); +d(); +self.default(); +self.def(); + +// should all work +a.default(); +b.default(); +c.default(); +d.default(); +self.default.default(); +self.def.default(); + +//// [mod.js] +"use strict"; +exports.__esModule = true; +exports["default"] = fun; +//// [a.js] +"use strict"; +var mod = require("./mod"); +module.exports = mod; +//// [b.js] +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +exports.__esModule = true; +exports.def = exports["default"] = void 0; +var a_1 = __importDefault(require("./a")); +var a_2 = __importDefault(require("./a")); +var a_3 = __importDefault(require("./a")); +var self = __importStar(require("./b")); +var a_4 = require("./a"); +__createBinding(exports, a_4, "default"); +var a_5 = require("./a"); +__createBinding(exports, a_5, "default", "def"); +a_1["default"] === a_2["default"]; +a_2["default"] === a_3["default"]; +a_3["default"] === a_3["default"]; +a_3["default"] === self["default"]; +self["default"] === self.def; +// should all fail +(0, a_1["default"])(); +(0, a_2["default"])(); +(0, a_3["default"])(); +(0, a_3["default"])(); +self["default"](); +self.def(); +// should all work +a_1["default"]["default"](); +a_2["default"]["default"](); +a_3["default"]["default"](); +a_3["default"]["default"](); +self["default"]["default"](); +self.def["default"](); diff --git a/tests/baselines/reference/esModuleInteropDefaultImports.symbols b/tests/baselines/reference/esModuleInteropDefaultImports.symbols new file mode 100644 index 0000000000000..05c18c13e4cfb --- /dev/null +++ b/tests/baselines/reference/esModuleInteropDefaultImports.symbols @@ -0,0 +1,121 @@ +=== tests/cases/compiler/mod.ts === +declare function fun(): void; +>fun : Symbol(fun, Decl(mod.ts, 0, 0)) + +export default fun; +>fun : Symbol(fun, Decl(mod.ts, 0, 0)) + +=== tests/cases/compiler/a.ts === +import mod = require("./mod"); +>mod : Symbol(mod, Decl(a.ts, 0, 0)) + +export = mod; +>mod : Symbol(mod, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +import a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +import { default as b } from "./a"; +>default : Symbol(mod, Decl(a.ts, 0, 30)) +>b : Symbol(b, Decl(b.ts, 1, 8)) + +import c, { default as d } from "./a"; +>c : Symbol(c, Decl(b.ts, 2, 6)) +>default : Symbol(mod, Decl(a.ts, 0, 30)) +>d : Symbol(d, Decl(b.ts, 2, 11)) + +import * as self from "./b"; +>self : Symbol(self, Decl(b.ts, 3, 6)) + +export { default } from "./a"; +>default : Symbol(self.default, Decl(b.ts, 4, 8)) + +export { default as def } from "./a"; +>default : Symbol(mod, Decl(a.ts, 0, 30)) +>def : Symbol(self.def, Decl(b.ts, 5, 8)) + +a === b; +>a : Symbol(a, Decl(b.ts, 0, 6)) +>b : Symbol(b, Decl(b.ts, 1, 8)) + +b === c; +>b : Symbol(b, Decl(b.ts, 1, 8)) +>c : Symbol(c, Decl(b.ts, 2, 6)) + +c === d; +>c : Symbol(c, Decl(b.ts, 2, 6)) +>d : Symbol(d, Decl(b.ts, 2, 11)) + +d === self.default; +>d : Symbol(d, Decl(b.ts, 2, 11)) +>self.default : Symbol(self.default, Decl(b.ts, 4, 8)) +>self : Symbol(self, Decl(b.ts, 3, 6)) +>default : Symbol(self.default, Decl(b.ts, 4, 8)) + +self.default === self.def; +>self.default : Symbol(self.default, Decl(b.ts, 4, 8)) +>self : Symbol(self, Decl(b.ts, 3, 6)) +>default : Symbol(self.default, Decl(b.ts, 4, 8)) +>self.def : Symbol(self.def, Decl(b.ts, 5, 8)) +>self : Symbol(self, Decl(b.ts, 3, 6)) +>def : Symbol(self.def, Decl(b.ts, 5, 8)) + +// should all fail +a(); +>a : Symbol(a, Decl(b.ts, 0, 6)) + +b(); +>b : Symbol(b, Decl(b.ts, 1, 8)) + +c(); +>c : Symbol(c, Decl(b.ts, 2, 6)) + +d(); +>d : Symbol(d, Decl(b.ts, 2, 11)) + +self.default(); +>self.default : Symbol(self.default, Decl(b.ts, 4, 8)) +>self : Symbol(self, Decl(b.ts, 3, 6)) +>default : Symbol(self.default, Decl(b.ts, 4, 8)) + +self.def(); +>self.def : Symbol(self.def, Decl(b.ts, 5, 8)) +>self : Symbol(self, Decl(b.ts, 3, 6)) +>def : Symbol(self.def, Decl(b.ts, 5, 8)) + +// should all work +a.default(); +>a.default : Symbol(a.default, Decl(mod.ts, 0, 29)) +>a : Symbol(a, Decl(b.ts, 0, 6)) +>default : Symbol(a.default, Decl(mod.ts, 0, 29)) + +b.default(); +>b.default : Symbol(a.default, Decl(mod.ts, 0, 29)) +>b : Symbol(b, Decl(b.ts, 1, 8)) +>default : Symbol(a.default, Decl(mod.ts, 0, 29)) + +c.default(); +>c.default : Symbol(a.default, Decl(mod.ts, 0, 29)) +>c : Symbol(c, Decl(b.ts, 2, 6)) +>default : Symbol(a.default, Decl(mod.ts, 0, 29)) + +d.default(); +>d.default : Symbol(a.default, Decl(mod.ts, 0, 29)) +>d : Symbol(d, Decl(b.ts, 2, 11)) +>default : Symbol(a.default, Decl(mod.ts, 0, 29)) + +self.default.default(); +>self.default.default : Symbol(a.default, Decl(mod.ts, 0, 29)) +>self.default : Symbol(self.default, Decl(b.ts, 4, 8)) +>self : Symbol(self, Decl(b.ts, 3, 6)) +>default : Symbol(self.default, Decl(b.ts, 4, 8)) +>default : Symbol(a.default, Decl(mod.ts, 0, 29)) + +self.def.default(); +>self.def.default : Symbol(a.default, Decl(mod.ts, 0, 29)) +>self.def : Symbol(self.def, Decl(b.ts, 5, 8)) +>self : Symbol(self, Decl(b.ts, 3, 6)) +>def : Symbol(self.def, Decl(b.ts, 5, 8)) +>default : Symbol(a.default, Decl(mod.ts, 0, 29)) + diff --git a/tests/baselines/reference/esModuleInteropDefaultImports.types b/tests/baselines/reference/esModuleInteropDefaultImports.types new file mode 100644 index 0000000000000..961e7063b2f9e --- /dev/null +++ b/tests/baselines/reference/esModuleInteropDefaultImports.types @@ -0,0 +1,138 @@ +=== tests/cases/compiler/mod.ts === +declare function fun(): void; +>fun : () => void + +export default fun; +>fun : () => void + +=== tests/cases/compiler/a.ts === +import mod = require("./mod"); +>mod : typeof mod + +export = mod; +>mod : typeof mod + +=== tests/cases/compiler/b.ts === +import a from "./a"; +>a : typeof a + +import { default as b } from "./a"; +>default : typeof a +>b : typeof a + +import c, { default as d } from "./a"; +>c : typeof a +>default : typeof a +>d : typeof a + +import * as self from "./b"; +>self : typeof self + +export { default } from "./a"; +>default : typeof a + +export { default as def } from "./a"; +>default : typeof a +>def : typeof a + +a === b; +>a === b : boolean +>a : typeof a +>b : typeof a + +b === c; +>b === c : boolean +>b : typeof a +>c : typeof a + +c === d; +>c === d : boolean +>c : typeof a +>d : typeof a + +d === self.default; +>d === self.default : boolean +>d : typeof a +>self.default : typeof a +>self : typeof self +>default : typeof a + +self.default === self.def; +>self.default === self.def : boolean +>self.default : typeof a +>self : typeof self +>default : typeof a +>self.def : typeof a +>self : typeof self +>def : typeof a + +// should all fail +a(); +>a() : any +>a : typeof a + +b(); +>b() : any +>b : typeof a + +c(); +>c() : any +>c : typeof a + +d(); +>d() : any +>d : typeof a + +self.default(); +>self.default() : any +>self.default : typeof a +>self : typeof self +>default : typeof a + +self.def(); +>self.def() : any +>self.def : typeof a +>self : typeof self +>def : typeof a + +// should all work +a.default(); +>a.default() : void +>a.default : () => void +>a : typeof a +>default : () => void + +b.default(); +>b.default() : void +>b.default : () => void +>b : typeof a +>default : () => void + +c.default(); +>c.default() : void +>c.default : () => void +>c : typeof a +>default : () => void + +d.default(); +>d.default() : void +>d.default : () => void +>d : typeof a +>default : () => void + +self.default.default(); +>self.default.default() : void +>self.default.default : () => void +>self.default : typeof a +>self : typeof self +>default : typeof a +>default : () => void + +self.def.default(); +>self.def.default() : void +>self.def.default : () => void +>self.def : typeof a +>self : typeof self +>def : typeof a +>default : () => void + diff --git a/tests/baselines/reference/moduleNodeDefaultImports(module=node16).errors.txt b/tests/baselines/reference/moduleNodeDefaultImports(module=node16).errors.txt new file mode 100644 index 0000000000000..f90724d92338b --- /dev/null +++ b/tests/baselines/reference/moduleNodeDefaultImports(module=node16).errors.txt @@ -0,0 +1,64 @@ +tests/cases/compiler/b.mts(15,1): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.mts(16,1): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.mts(17,1): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.mts(18,1): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.mts(19,6): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.mts(20,6): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + + +==== tests/cases/compiler/mod.cts (0 errors) ==== + declare function fun(): void; + export default fun; +==== tests/cases/compiler/b.mts (6 errors) ==== + import a from "./mod.cjs"; + import { default as b } from "./mod.cjs"; + import c, { default as d } from "./mod.cjs"; + import * as self from "./b.mjs"; + export { default } from "./mod.cjs"; + export { default as def } from "./mod.cjs"; + + a === b; + b === c; + c === d; + d === self.default; + self.default === self.def; + + // should all fail + a(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + b(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + c(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + d(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + self.default(); + ~~~~~~~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + self.def(); + ~~~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + + // should all work + a.default(); + b.default(); + c.default(); + d.default(); + self.default.default(); + self.def.default(); \ No newline at end of file diff --git a/tests/baselines/reference/moduleNodeDefaultImports(module=node16).js b/tests/baselines/reference/moduleNodeDefaultImports(module=node16).js new file mode 100644 index 0000000000000..1d6e31ec0afb2 --- /dev/null +++ b/tests/baselines/reference/moduleNodeDefaultImports(module=node16).js @@ -0,0 +1,65 @@ +//// [tests/cases/compiler/moduleNodeDefaultImports.ts] //// + +//// [mod.cts] +declare function fun(): void; +export default fun; +//// [b.mts] +import a from "./mod.cjs"; +import { default as b } from "./mod.cjs"; +import c, { default as d } from "./mod.cjs"; +import * as self from "./b.mjs"; +export { default } from "./mod.cjs"; +export { default as def } from "./mod.cjs"; + +a === b; +b === c; +c === d; +d === self.default; +self.default === self.def; + +// should all fail +a(); +b(); +c(); +d(); +self.default(); +self.def(); + +// should all work +a.default(); +b.default(); +c.default(); +d.default(); +self.default.default(); +self.def.default(); + +//// [mod.cjs] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = fun; +//// [b.mjs] +import a from "./mod.cjs"; +import { default as b } from "./mod.cjs"; +import c, { default as d } from "./mod.cjs"; +import * as self from "./b.mjs"; +export { default } from "./mod.cjs"; +export { default as def } from "./mod.cjs"; +a === b; +b === c; +c === d; +d === self.default; +self.default === self.def; +// should all fail +a(); +b(); +c(); +d(); +self.default(); +self.def(); +// should all work +a.default(); +b.default(); +c.default(); +d.default(); +self.default.default(); +self.def.default(); diff --git a/tests/baselines/reference/moduleNodeDefaultImports(module=node16).symbols b/tests/baselines/reference/moduleNodeDefaultImports(module=node16).symbols new file mode 100644 index 0000000000000..7d475bb0e7e6a --- /dev/null +++ b/tests/baselines/reference/moduleNodeDefaultImports(module=node16).symbols @@ -0,0 +1,114 @@ +=== tests/cases/compiler/mod.cts === +declare function fun(): void; +>fun : Symbol(fun, Decl(mod.cts, 0, 0)) + +export default fun; +>fun : Symbol(fun, Decl(mod.cts, 0, 0)) + +=== tests/cases/compiler/b.mts === +import a from "./mod.cjs"; +>a : Symbol(a, Decl(b.mts, 0, 6)) + +import { default as b } from "./mod.cjs"; +>default : Symbol(a, Decl(mod.cts, 0, 0)) +>b : Symbol(b, Decl(b.mts, 1, 8)) + +import c, { default as d } from "./mod.cjs"; +>c : Symbol(c, Decl(b.mts, 2, 6)) +>default : Symbol(a, Decl(mod.cts, 0, 0)) +>d : Symbol(d, Decl(b.mts, 2, 11)) + +import * as self from "./b.mjs"; +>self : Symbol(self, Decl(b.mts, 3, 6)) + +export { default } from "./mod.cjs"; +>default : Symbol(self.default, Decl(b.mts, 4, 8)) + +export { default as def } from "./mod.cjs"; +>default : Symbol(a, Decl(mod.cts, 0, 0)) +>def : Symbol(self.def, Decl(b.mts, 5, 8)) + +a === b; +>a : Symbol(a, Decl(b.mts, 0, 6)) +>b : Symbol(b, Decl(b.mts, 1, 8)) + +b === c; +>b : Symbol(b, Decl(b.mts, 1, 8)) +>c : Symbol(c, Decl(b.mts, 2, 6)) + +c === d; +>c : Symbol(c, Decl(b.mts, 2, 6)) +>d : Symbol(d, Decl(b.mts, 2, 11)) + +d === self.default; +>d : Symbol(d, Decl(b.mts, 2, 11)) +>self.default : Symbol(self.default, Decl(b.mts, 4, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>default : Symbol(self.default, Decl(b.mts, 4, 8)) + +self.default === self.def; +>self.default : Symbol(self.default, Decl(b.mts, 4, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>default : Symbol(self.default, Decl(b.mts, 4, 8)) +>self.def : Symbol(self.def, Decl(b.mts, 5, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>def : Symbol(self.def, Decl(b.mts, 5, 8)) + +// should all fail +a(); +>a : Symbol(a, Decl(b.mts, 0, 6)) + +b(); +>b : Symbol(b, Decl(b.mts, 1, 8)) + +c(); +>c : Symbol(c, Decl(b.mts, 2, 6)) + +d(); +>d : Symbol(d, Decl(b.mts, 2, 11)) + +self.default(); +>self.default : Symbol(self.default, Decl(b.mts, 4, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>default : Symbol(self.default, Decl(b.mts, 4, 8)) + +self.def(); +>self.def : Symbol(self.def, Decl(b.mts, 5, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>def : Symbol(self.def, Decl(b.mts, 5, 8)) + +// should all work +a.default(); +>a.default : Symbol(a.default, Decl(mod.cts, 0, 29)) +>a : Symbol(a, Decl(b.mts, 0, 6)) +>default : Symbol(a.default, Decl(mod.cts, 0, 29)) + +b.default(); +>b.default : Symbol(a.default, Decl(mod.cts, 0, 29)) +>b : Symbol(b, Decl(b.mts, 1, 8)) +>default : Symbol(a.default, Decl(mod.cts, 0, 29)) + +c.default(); +>c.default : Symbol(a.default, Decl(mod.cts, 0, 29)) +>c : Symbol(c, Decl(b.mts, 2, 6)) +>default : Symbol(a.default, Decl(mod.cts, 0, 29)) + +d.default(); +>d.default : Symbol(a.default, Decl(mod.cts, 0, 29)) +>d : Symbol(d, Decl(b.mts, 2, 11)) +>default : Symbol(a.default, Decl(mod.cts, 0, 29)) + +self.default.default(); +>self.default.default : Symbol(a.default, Decl(mod.cts, 0, 29)) +>self.default : Symbol(self.default, Decl(b.mts, 4, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>default : Symbol(self.default, Decl(b.mts, 4, 8)) +>default : Symbol(a.default, Decl(mod.cts, 0, 29)) + +self.def.default(); +>self.def.default : Symbol(a.default, Decl(mod.cts, 0, 29)) +>self.def : Symbol(self.def, Decl(b.mts, 5, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>def : Symbol(self.def, Decl(b.mts, 5, 8)) +>default : Symbol(a.default, Decl(mod.cts, 0, 29)) + diff --git a/tests/baselines/reference/moduleNodeDefaultImports(module=node16).types b/tests/baselines/reference/moduleNodeDefaultImports(module=node16).types new file mode 100644 index 0000000000000..653dac121b8b0 --- /dev/null +++ b/tests/baselines/reference/moduleNodeDefaultImports(module=node16).types @@ -0,0 +1,131 @@ +=== tests/cases/compiler/mod.cts === +declare function fun(): void; +>fun : () => void + +export default fun; +>fun : () => void + +=== tests/cases/compiler/b.mts === +import a from "./mod.cjs"; +>a : typeof a + +import { default as b } from "./mod.cjs"; +>default : typeof a +>b : typeof a + +import c, { default as d } from "./mod.cjs"; +>c : typeof a +>default : typeof a +>d : typeof a + +import * as self from "./b.mjs"; +>self : typeof self + +export { default } from "./mod.cjs"; +>default : typeof a + +export { default as def } from "./mod.cjs"; +>default : typeof a +>def : typeof a + +a === b; +>a === b : boolean +>a : typeof a +>b : typeof a + +b === c; +>b === c : boolean +>b : typeof a +>c : typeof a + +c === d; +>c === d : boolean +>c : typeof a +>d : typeof a + +d === self.default; +>d === self.default : boolean +>d : typeof a +>self.default : typeof a +>self : typeof self +>default : typeof a + +self.default === self.def; +>self.default === self.def : boolean +>self.default : typeof a +>self : typeof self +>default : typeof a +>self.def : typeof a +>self : typeof self +>def : typeof a + +// should all fail +a(); +>a() : any +>a : typeof a + +b(); +>b() : any +>b : typeof a + +c(); +>c() : any +>c : typeof a + +d(); +>d() : any +>d : typeof a + +self.default(); +>self.default() : any +>self.default : typeof a +>self : typeof self +>default : typeof a + +self.def(); +>self.def() : any +>self.def : typeof a +>self : typeof self +>def : typeof a + +// should all work +a.default(); +>a.default() : void +>a.default : () => void +>a : typeof a +>default : () => void + +b.default(); +>b.default() : void +>b.default : () => void +>b : typeof a +>default : () => void + +c.default(); +>c.default() : void +>c.default : () => void +>c : typeof a +>default : () => void + +d.default(); +>d.default() : void +>d.default : () => void +>d : typeof a +>default : () => void + +self.default.default(); +>self.default.default() : void +>self.default.default : () => void +>self.default : typeof a +>self : typeof self +>default : typeof a +>default : () => void + +self.def.default(); +>self.def.default() : void +>self.def.default : () => void +>self.def : typeof a +>self : typeof self +>def : typeof a +>default : () => void + diff --git a/tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).errors.txt b/tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).errors.txt new file mode 100644 index 0000000000000..f90724d92338b --- /dev/null +++ b/tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).errors.txt @@ -0,0 +1,64 @@ +tests/cases/compiler/b.mts(15,1): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.mts(16,1): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.mts(17,1): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.mts(18,1): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.mts(19,6): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. +tests/cases/compiler/b.mts(20,6): error TS2349: This expression is not callable. + Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + + +==== tests/cases/compiler/mod.cts (0 errors) ==== + declare function fun(): void; + export default fun; +==== tests/cases/compiler/b.mts (6 errors) ==== + import a from "./mod.cjs"; + import { default as b } from "./mod.cjs"; + import c, { default as d } from "./mod.cjs"; + import * as self from "./b.mjs"; + export { default } from "./mod.cjs"; + export { default as def } from "./mod.cjs"; + + a === b; + b === c; + c === d; + d === self.default; + self.default === self.def; + + // should all fail + a(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + b(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + c(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + d(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + self.default(); + ~~~~~~~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + self.def(); + ~~~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'typeof import("tests/cases/compiler/mod")' has no call signatures. + + // should all work + a.default(); + b.default(); + c.default(); + d.default(); + self.default.default(); + self.def.default(); \ No newline at end of file diff --git a/tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).js b/tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).js new file mode 100644 index 0000000000000..1d6e31ec0afb2 --- /dev/null +++ b/tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).js @@ -0,0 +1,65 @@ +//// [tests/cases/compiler/moduleNodeDefaultImports.ts] //// + +//// [mod.cts] +declare function fun(): void; +export default fun; +//// [b.mts] +import a from "./mod.cjs"; +import { default as b } from "./mod.cjs"; +import c, { default as d } from "./mod.cjs"; +import * as self from "./b.mjs"; +export { default } from "./mod.cjs"; +export { default as def } from "./mod.cjs"; + +a === b; +b === c; +c === d; +d === self.default; +self.default === self.def; + +// should all fail +a(); +b(); +c(); +d(); +self.default(); +self.def(); + +// should all work +a.default(); +b.default(); +c.default(); +d.default(); +self.default.default(); +self.def.default(); + +//// [mod.cjs] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = fun; +//// [b.mjs] +import a from "./mod.cjs"; +import { default as b } from "./mod.cjs"; +import c, { default as d } from "./mod.cjs"; +import * as self from "./b.mjs"; +export { default } from "./mod.cjs"; +export { default as def } from "./mod.cjs"; +a === b; +b === c; +c === d; +d === self.default; +self.default === self.def; +// should all fail +a(); +b(); +c(); +d(); +self.default(); +self.def(); +// should all work +a.default(); +b.default(); +c.default(); +d.default(); +self.default.default(); +self.def.default(); diff --git a/tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).symbols b/tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).symbols new file mode 100644 index 0000000000000..7d475bb0e7e6a --- /dev/null +++ b/tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).symbols @@ -0,0 +1,114 @@ +=== tests/cases/compiler/mod.cts === +declare function fun(): void; +>fun : Symbol(fun, Decl(mod.cts, 0, 0)) + +export default fun; +>fun : Symbol(fun, Decl(mod.cts, 0, 0)) + +=== tests/cases/compiler/b.mts === +import a from "./mod.cjs"; +>a : Symbol(a, Decl(b.mts, 0, 6)) + +import { default as b } from "./mod.cjs"; +>default : Symbol(a, Decl(mod.cts, 0, 0)) +>b : Symbol(b, Decl(b.mts, 1, 8)) + +import c, { default as d } from "./mod.cjs"; +>c : Symbol(c, Decl(b.mts, 2, 6)) +>default : Symbol(a, Decl(mod.cts, 0, 0)) +>d : Symbol(d, Decl(b.mts, 2, 11)) + +import * as self from "./b.mjs"; +>self : Symbol(self, Decl(b.mts, 3, 6)) + +export { default } from "./mod.cjs"; +>default : Symbol(self.default, Decl(b.mts, 4, 8)) + +export { default as def } from "./mod.cjs"; +>default : Symbol(a, Decl(mod.cts, 0, 0)) +>def : Symbol(self.def, Decl(b.mts, 5, 8)) + +a === b; +>a : Symbol(a, Decl(b.mts, 0, 6)) +>b : Symbol(b, Decl(b.mts, 1, 8)) + +b === c; +>b : Symbol(b, Decl(b.mts, 1, 8)) +>c : Symbol(c, Decl(b.mts, 2, 6)) + +c === d; +>c : Symbol(c, Decl(b.mts, 2, 6)) +>d : Symbol(d, Decl(b.mts, 2, 11)) + +d === self.default; +>d : Symbol(d, Decl(b.mts, 2, 11)) +>self.default : Symbol(self.default, Decl(b.mts, 4, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>default : Symbol(self.default, Decl(b.mts, 4, 8)) + +self.default === self.def; +>self.default : Symbol(self.default, Decl(b.mts, 4, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>default : Symbol(self.default, Decl(b.mts, 4, 8)) +>self.def : Symbol(self.def, Decl(b.mts, 5, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>def : Symbol(self.def, Decl(b.mts, 5, 8)) + +// should all fail +a(); +>a : Symbol(a, Decl(b.mts, 0, 6)) + +b(); +>b : Symbol(b, Decl(b.mts, 1, 8)) + +c(); +>c : Symbol(c, Decl(b.mts, 2, 6)) + +d(); +>d : Symbol(d, Decl(b.mts, 2, 11)) + +self.default(); +>self.default : Symbol(self.default, Decl(b.mts, 4, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>default : Symbol(self.default, Decl(b.mts, 4, 8)) + +self.def(); +>self.def : Symbol(self.def, Decl(b.mts, 5, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>def : Symbol(self.def, Decl(b.mts, 5, 8)) + +// should all work +a.default(); +>a.default : Symbol(a.default, Decl(mod.cts, 0, 29)) +>a : Symbol(a, Decl(b.mts, 0, 6)) +>default : Symbol(a.default, Decl(mod.cts, 0, 29)) + +b.default(); +>b.default : Symbol(a.default, Decl(mod.cts, 0, 29)) +>b : Symbol(b, Decl(b.mts, 1, 8)) +>default : Symbol(a.default, Decl(mod.cts, 0, 29)) + +c.default(); +>c.default : Symbol(a.default, Decl(mod.cts, 0, 29)) +>c : Symbol(c, Decl(b.mts, 2, 6)) +>default : Symbol(a.default, Decl(mod.cts, 0, 29)) + +d.default(); +>d.default : Symbol(a.default, Decl(mod.cts, 0, 29)) +>d : Symbol(d, Decl(b.mts, 2, 11)) +>default : Symbol(a.default, Decl(mod.cts, 0, 29)) + +self.default.default(); +>self.default.default : Symbol(a.default, Decl(mod.cts, 0, 29)) +>self.default : Symbol(self.default, Decl(b.mts, 4, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>default : Symbol(self.default, Decl(b.mts, 4, 8)) +>default : Symbol(a.default, Decl(mod.cts, 0, 29)) + +self.def.default(); +>self.def.default : Symbol(a.default, Decl(mod.cts, 0, 29)) +>self.def : Symbol(self.def, Decl(b.mts, 5, 8)) +>self : Symbol(self, Decl(b.mts, 3, 6)) +>def : Symbol(self.def, Decl(b.mts, 5, 8)) +>default : Symbol(a.default, Decl(mod.cts, 0, 29)) + diff --git a/tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).types b/tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).types new file mode 100644 index 0000000000000..653dac121b8b0 --- /dev/null +++ b/tests/baselines/reference/moduleNodeDefaultImports(module=nodenext).types @@ -0,0 +1,131 @@ +=== tests/cases/compiler/mod.cts === +declare function fun(): void; +>fun : () => void + +export default fun; +>fun : () => void + +=== tests/cases/compiler/b.mts === +import a from "./mod.cjs"; +>a : typeof a + +import { default as b } from "./mod.cjs"; +>default : typeof a +>b : typeof a + +import c, { default as d } from "./mod.cjs"; +>c : typeof a +>default : typeof a +>d : typeof a + +import * as self from "./b.mjs"; +>self : typeof self + +export { default } from "./mod.cjs"; +>default : typeof a + +export { default as def } from "./mod.cjs"; +>default : typeof a +>def : typeof a + +a === b; +>a === b : boolean +>a : typeof a +>b : typeof a + +b === c; +>b === c : boolean +>b : typeof a +>c : typeof a + +c === d; +>c === d : boolean +>c : typeof a +>d : typeof a + +d === self.default; +>d === self.default : boolean +>d : typeof a +>self.default : typeof a +>self : typeof self +>default : typeof a + +self.default === self.def; +>self.default === self.def : boolean +>self.default : typeof a +>self : typeof self +>default : typeof a +>self.def : typeof a +>self : typeof self +>def : typeof a + +// should all fail +a(); +>a() : any +>a : typeof a + +b(); +>b() : any +>b : typeof a + +c(); +>c() : any +>c : typeof a + +d(); +>d() : any +>d : typeof a + +self.default(); +>self.default() : any +>self.default : typeof a +>self : typeof self +>default : typeof a + +self.def(); +>self.def() : any +>self.def : typeof a +>self : typeof self +>def : typeof a + +// should all work +a.default(); +>a.default() : void +>a.default : () => void +>a : typeof a +>default : () => void + +b.default(); +>b.default() : void +>b.default : () => void +>b : typeof a +>default : () => void + +c.default(); +>c.default() : void +>c.default : () => void +>c : typeof a +>default : () => void + +d.default(); +>d.default() : void +>d.default : () => void +>d : typeof a +>default : () => void + +self.default.default(); +>self.default.default() : void +>self.default.default : () => void +>self.default : typeof a +>self : typeof self +>default : typeof a +>default : () => void + +self.def.default(); +>self.def.default() : void +>self.def.default : () => void +>self.def : typeof a +>self : typeof self +>def : typeof a +>default : () => void + diff --git a/tests/cases/compiler/esModuleInteropDefaultImports.ts b/tests/cases/compiler/esModuleInteropDefaultImports.ts new file mode 100644 index 0000000000000..0ddd2df567756 --- /dev/null +++ b/tests/cases/compiler/esModuleInteropDefaultImports.ts @@ -0,0 +1,36 @@ +// @esModuleInterop: true +// @filename: mod.ts +declare function fun(): void; +export default fun; +// @filename: a.ts +import mod = require("./mod"); +export = mod; +// @filename: b.ts +import a from "./a"; +import { default as b } from "./a"; +import c, { default as d } from "./a"; +import * as self from "./b"; +export { default } from "./a"; +export { default as def } from "./a"; + +a === b; +b === c; +c === d; +d === self.default; +self.default === self.def; + +// should all fail +a(); +b(); +c(); +d(); +self.default(); +self.def(); + +// should all work +a.default(); +b.default(); +c.default(); +d.default(); +self.default.default(); +self.def.default(); \ No newline at end of file diff --git a/tests/cases/compiler/moduleNodeDefaultImports.ts b/tests/cases/compiler/moduleNodeDefaultImports.ts new file mode 100644 index 0000000000000..906de682bd610 --- /dev/null +++ b/tests/cases/compiler/moduleNodeDefaultImports.ts @@ -0,0 +1,33 @@ +// @module: node16,nodenext +// @filename: mod.cts +declare function fun(): void; +export default fun; +// @filename: b.mts +import a from "./mod.cjs"; +import { default as b } from "./mod.cjs"; +import c, { default as d } from "./mod.cjs"; +import * as self from "./b.mjs"; +export { default } from "./mod.cjs"; +export { default as def } from "./mod.cjs"; + +a === b; +b === c; +c === d; +d === self.default; +self.default === self.def; + +// should all fail +a(); +b(); +c(); +d(); +self.default(); +self.def(); + +// should all work +a.default(); +b.default(); +c.default(); +d.default(); +self.default.default(); +self.def.default(); \ No newline at end of file From 5969ae9ef76f5ae518558d7925fbf1c518060a4b Mon Sep 17 00:00:00 2001 From: Oleksandr T Date: Fri, 19 Aug 2022 19:34:42 +0300 Subject: [PATCH 03/16] fix(50075): do not strip undefined from the function class properties (#50169) --- src/compiler/checker.ts | 2 +- ...jsdocFunctionClassPropertiesDeclaration.js | 47 +++++++++++++++++++ ...FunctionClassPropertiesDeclaration.symbols | 32 +++++++++++++ ...ocFunctionClassPropertiesDeclaration.types | 38 +++++++++++++++ ...jsdocFunctionClassPropertiesDeclaration.ts | 18 +++++++ 5 files changed, 136 insertions(+), 1 deletion(-) create mode 100644 tests/baselines/reference/jsdocFunctionClassPropertiesDeclaration.js create mode 100644 tests/baselines/reference/jsdocFunctionClassPropertiesDeclaration.symbols create mode 100644 tests/baselines/reference/jsdocFunctionClassPropertiesDeclaration.types create mode 100644 tests/cases/compiler/jsdocFunctionClassPropertiesDeclaration.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 8c8101e87374c..e2594f6592c14 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -8154,7 +8154,7 @@ namespace ts { factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? ModifierFlags.Readonly : 0) | flag), name, p.flags & SymbolFlags.Optional ? factory.createToken(SyntaxKind.QuestionToken) : undefined, - isPrivate ? undefined : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled), + isPrivate ? undefined : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled), // TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357 // interface members can't have initializers, however class members _can_ /*initializer*/ undefined diff --git a/tests/baselines/reference/jsdocFunctionClassPropertiesDeclaration.js b/tests/baselines/reference/jsdocFunctionClassPropertiesDeclaration.js new file mode 100644 index 0000000000000..7f4739ad95159 --- /dev/null +++ b/tests/baselines/reference/jsdocFunctionClassPropertiesDeclaration.js @@ -0,0 +1,47 @@ +//// [a.js] +/** + * @param {number | undefined} x + * @param {number | undefined} y + */ +export function Foo(x, y) { + if (!(this instanceof Foo)) { + return new Foo(x, y); + } + this.x = x; + this.y = y; +} + + +//// [a.js] +"use strict"; +exports.__esModule = true; +exports.Foo = void 0; +/** + * @param {number | undefined} x + * @param {number | undefined} y + */ +function Foo(x, y) { + if (!(this instanceof Foo)) { + return new Foo(x, y); + } + this.x = x; + this.y = y; +} +exports.Foo = Foo; + + +//// [a.d.ts] +/** + * @param {number | undefined} x + * @param {number | undefined} y + */ +export function Foo(x: number | undefined, y: number | undefined): Foo; +export class Foo { + /** + * @param {number | undefined} x + * @param {number | undefined} y + */ + constructor(x: number | undefined, y: number | undefined); + x: number | undefined; + y: number | undefined; +} diff --git a/tests/baselines/reference/jsdocFunctionClassPropertiesDeclaration.symbols b/tests/baselines/reference/jsdocFunctionClassPropertiesDeclaration.symbols new file mode 100644 index 0000000000000..674286c07001e --- /dev/null +++ b/tests/baselines/reference/jsdocFunctionClassPropertiesDeclaration.symbols @@ -0,0 +1,32 @@ +=== /a.js === +/** + * @param {number | undefined} x + * @param {number | undefined} y + */ +export function Foo(x, y) { +>Foo : Symbol(Foo, Decl(a.js, 0, 0)) +>x : Symbol(x, Decl(a.js, 4, 20)) +>y : Symbol(y, Decl(a.js, 4, 22)) + + if (!(this instanceof Foo)) { +>this : Symbol(Foo, Decl(a.js, 0, 0)) +>Foo : Symbol(Foo, Decl(a.js, 0, 0)) + + return new Foo(x, y); +>Foo : Symbol(Foo, Decl(a.js, 0, 0)) +>x : Symbol(x, Decl(a.js, 4, 20)) +>y : Symbol(y, Decl(a.js, 4, 22)) + } + this.x = x; +>this.x : Symbol(Foo.x, Decl(a.js, 7, 5)) +>this : Symbol(Foo, Decl(a.js, 0, 0)) +>x : Symbol(Foo.x, Decl(a.js, 7, 5)) +>x : Symbol(x, Decl(a.js, 4, 20)) + + this.y = y; +>this.y : Symbol(Foo.y, Decl(a.js, 8, 15)) +>this : Symbol(Foo, Decl(a.js, 0, 0)) +>y : Symbol(Foo.y, Decl(a.js, 8, 15)) +>y : Symbol(y, Decl(a.js, 4, 22)) +} + diff --git a/tests/baselines/reference/jsdocFunctionClassPropertiesDeclaration.types b/tests/baselines/reference/jsdocFunctionClassPropertiesDeclaration.types new file mode 100644 index 0000000000000..21b1b03194456 --- /dev/null +++ b/tests/baselines/reference/jsdocFunctionClassPropertiesDeclaration.types @@ -0,0 +1,38 @@ +=== /a.js === +/** + * @param {number | undefined} x + * @param {number | undefined} y + */ +export function Foo(x, y) { +>Foo : typeof Foo +>x : number | undefined +>y : number | undefined + + if (!(this instanceof Foo)) { +>!(this instanceof Foo) : boolean +>(this instanceof Foo) : boolean +>this instanceof Foo : boolean +>this : this +>Foo : typeof Foo + + return new Foo(x, y); +>new Foo(x, y) : Foo +>Foo : typeof Foo +>x : number | undefined +>y : number | undefined + } + this.x = x; +>this.x = x : number | undefined +>this.x : any +>this : this +>x : any +>x : number | undefined + + this.y = y; +>this.y = y : number | undefined +>this.y : any +>this : this +>y : any +>y : number | undefined +} + diff --git a/tests/cases/compiler/jsdocFunctionClassPropertiesDeclaration.ts b/tests/cases/compiler/jsdocFunctionClassPropertiesDeclaration.ts new file mode 100644 index 0000000000000..321e9c7f3c81d --- /dev/null +++ b/tests/cases/compiler/jsdocFunctionClassPropertiesDeclaration.ts @@ -0,0 +1,18 @@ +// @allowJs: true +// @checkJs: true +// @strict: true +// @declaration: true +// @outDir: ./out +// @filename: /a.js + +/** + * @param {number | undefined} x + * @param {number | undefined} y + */ +export function Foo(x, y) { + if (!(this instanceof Foo)) { + return new Foo(x, y); + } + this.x = x; + this.y = y; +} From ef88fbb8ab6c3da270f772373c2db1c5a1e3d9af Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 19 Aug 2022 09:42:14 -0700 Subject: [PATCH 04/16] Remove some unused deps and dead code (#50367) --- Gulpfile.js | 4 +-- package-lock.json | 81 ------------------------------------------ package.json | 6 ---- scripts/build/tests.js | 1 - 4 files changed, 2 insertions(+), 90 deletions(-) diff --git a/Gulpfile.js b/Gulpfile.js index ec4fafe66ba68..1f92049377865 100644 --- a/Gulpfile.js +++ b/Gulpfile.js @@ -8,7 +8,6 @@ const del = require("del"); const rename = require("gulp-rename"); const concat = require("gulp-concat"); const merge2 = require("merge2"); -const mkdirp = require("mkdirp"); const { src, dest, task, parallel, series, watch } = require("gulp"); const { append, transform } = require("gulp-insert"); const { prependFile } = require("./scripts/build/prepend"); @@ -27,9 +26,10 @@ task("scripts").description = "Builds files in the 'scripts' folder."; const cleanScripts = () => cleanProject("scripts"); cleanTasks.push(cleanScripts); +/** @type {{ libs: string[]; paths: Record; }} */ const libraries = readJson("./src/lib/libs.json"); const libs = libraries.libs.map(lib => { - const relativeSources = ["header.d.ts"].concat(libraries.sources && libraries.sources[lib] || [lib + ".d.ts"]); + const relativeSources = ["header.d.ts", lib + ".d.ts"]; const relativeTarget = libraries.paths && libraries.paths[lib] || ("lib." + lib + ".d.ts"); const sources = relativeSources.map(s => path.posix.join("src/lib", s)); const target = `built/local/${relativeTarget}`; diff --git a/package-lock.json b/package-lock.json index 9eac430388dda..1949d70b207e5 100644 --- a/package-lock.json +++ b/package-lock.json @@ -16,7 +16,6 @@ "@octokit/rest": "latest", "@types/async": "latest", "@types/chai": "latest", - "@types/convert-source-map": "latest", "@types/fs-extra": "^9.0.13", "@types/glob": "latest", "@types/gulp": "^4.0.9", @@ -26,14 +25,12 @@ "@types/gulp-sourcemaps": "latest", "@types/merge2": "latest", "@types/microsoft__typescript-etw": "latest", - "@types/minimatch": "latest", "@types/minimist": "latest", "@types/mkdirp": "latest", "@types/mocha": "latest", "@types/ms": "latest", "@types/node": "latest", "@types/node-fetch": "^2.6.2", - "@types/q": "latest", "@types/source-map-support": "latest", "@types/xml2js": "^0.4.11", "@typescript-eslint/eslint-plugin": "^5.28.0", @@ -43,7 +40,6 @@ "azure-devops-node-api": "^11.1.1", "chai": "latest", "chalk": "^4.1.2", - "convert-source-map": "latest", "del": "6.1.1", "diff": "^5.1.0", "eslint": "8.17.0", @@ -68,11 +64,9 @@ "ms": "^2.1.3", "node-fetch": "^2.6.7", "prex": "^0.4.7", - "q": "latest", "source-map-support": "latest", "typescript": "^4.5.5", "vinyl": "latest", - "vinyl-sourcemaps-apply": "latest", "which": "^2.0.2", "xml2js": "^0.4.23" }, @@ -448,12 +442,6 @@ "integrity": "sha512-hC7OMnszpxhZPduX+m+nrx+uFoLkWOMiR4oa/AZF3MuSETYTZmFfJAHqZEM8MVlvfG7BEUcgvtwoCTxBp6hm3g==", "dev": true }, - "node_modules/@types/convert-source-map": { - "version": "1.5.2", - "resolved": "https://registry.npmjs.org/@types/convert-source-map/-/convert-source-map-1.5.2.tgz", - "integrity": "sha512-tHs++ZeXer40kCF2JpE51Hg7t4HPa18B1b1Dzy96S0eCw8QKECNMYMfwa1edK/x8yCN0r4e6ewvLcc5CsVGkdg==", - "dev": true - }, "node_modules/@types/expect": { "version": "1.20.4", "resolved": "https://registry.npmjs.org/@types/expect/-/expect-1.20.4.tgz", @@ -614,12 +602,6 @@ "form-data": "^3.0.0" } }, - "node_modules/@types/q": { - "version": "1.5.5", - "resolved": "https://registry.npmjs.org/@types/q/-/q-1.5.5.tgz", - "integrity": "sha512-L28j2FcJfSZOnL1WBjDYp2vUHCeIFlyYI/53EwD/rKUBQ7MtUUfbQWiyKJGpcnv4/WgrhWsFKrcPstcAt/J0tQ==", - "dev": true - }, "node_modules/@types/source-map-support": { "version": "0.5.4", "resolved": "https://registry.npmjs.org/@types/source-map-support/-/source-map-support-0.5.4.tgz", @@ -6571,16 +6553,6 @@ "node": ">=6" } }, - "node_modules/q": { - "version": "1.5.1", - "resolved": "https://registry.npmjs.org/q/-/q-1.5.1.tgz", - "integrity": "sha512-kV/CThkXo6xyFEZUugw/+pIOywXcDbFYgSct5cT3gqlbkBE1SJdwy6UQoZvodiWF/ckQLZyDE/Bu1M6gVu5lVw==", - "dev": true, - "engines": { - "node": ">=0.6.0", - "teleport": ">=0.2.0" - } - }, "node_modules/qs": { "version": "6.11.0", "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz", @@ -8337,24 +8309,6 @@ "node": ">=0.10.0" } }, - "node_modules/vinyl-sourcemaps-apply": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/vinyl-sourcemaps-apply/-/vinyl-sourcemaps-apply-0.2.1.tgz", - "integrity": "sha512-+oDh3KYZBoZC8hfocrbrxbLUeaYtQK7J5WU5Br9VqWqmCll3tFJqKp97GC9GmMsVIL0qnx2DgEDVxdo5EZ5sSw==", - "dev": true, - "dependencies": { - "source-map": "^0.5.1" - } - }, - "node_modules/vinyl-sourcemaps-apply/node_modules/source-map": { - "version": "0.5.7", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", - "integrity": "sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/webidl-conversions": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", @@ -8903,12 +8857,6 @@ "integrity": "sha512-hC7OMnszpxhZPduX+m+nrx+uFoLkWOMiR4oa/AZF3MuSETYTZmFfJAHqZEM8MVlvfG7BEUcgvtwoCTxBp6hm3g==", "dev": true }, - "@types/convert-source-map": { - "version": "1.5.2", - "resolved": "https://registry.npmjs.org/@types/convert-source-map/-/convert-source-map-1.5.2.tgz", - "integrity": "sha512-tHs++ZeXer40kCF2JpE51Hg7t4HPa18B1b1Dzy96S0eCw8QKECNMYMfwa1edK/x8yCN0r4e6ewvLcc5CsVGkdg==", - "dev": true - }, "@types/expect": { "version": "1.20.4", "resolved": "https://registry.npmjs.org/@types/expect/-/expect-1.20.4.tgz", @@ -9069,12 +9017,6 @@ "form-data": "^3.0.0" } }, - "@types/q": { - "version": "1.5.5", - "resolved": "https://registry.npmjs.org/@types/q/-/q-1.5.5.tgz", - "integrity": "sha512-L28j2FcJfSZOnL1WBjDYp2vUHCeIFlyYI/53EwD/rKUBQ7MtUUfbQWiyKJGpcnv4/WgrhWsFKrcPstcAt/J0tQ==", - "dev": true - }, "@types/source-map-support": { "version": "0.5.4", "resolved": "https://registry.npmjs.org/@types/source-map-support/-/source-map-support-0.5.4.tgz", @@ -13700,12 +13642,6 @@ "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==", "dev": true }, - "q": { - "version": "1.5.1", - "resolved": "https://registry.npmjs.org/q/-/q-1.5.1.tgz", - "integrity": "sha512-kV/CThkXo6xyFEZUugw/+pIOywXcDbFYgSct5cT3gqlbkBE1SJdwy6UQoZvodiWF/ckQLZyDE/Bu1M6gVu5lVw==", - "dev": true - }, "qs": { "version": "6.11.0", "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz", @@ -15109,23 +15045,6 @@ } } }, - "vinyl-sourcemaps-apply": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/vinyl-sourcemaps-apply/-/vinyl-sourcemaps-apply-0.2.1.tgz", - "integrity": "sha512-+oDh3KYZBoZC8hfocrbrxbLUeaYtQK7J5WU5Br9VqWqmCll3tFJqKp97GC9GmMsVIL0qnx2DgEDVxdo5EZ5sSw==", - "dev": true, - "requires": { - "source-map": "^0.5.1" - }, - "dependencies": { - "source-map": { - "version": "0.5.7", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", - "integrity": "sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==", - "dev": true - } - } - }, "webidl-conversions": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", diff --git a/package.json b/package.json index d0655e1343e34..23d2b40b5cfe2 100644 --- a/package.json +++ b/package.json @@ -32,7 +32,6 @@ "@octokit/rest": "latest", "@types/async": "latest", "@types/chai": "latest", - "@types/convert-source-map": "latest", "@types/fs-extra": "^9.0.13", "@types/glob": "latest", "@types/gulp": "^4.0.9", @@ -42,14 +41,12 @@ "@types/gulp-sourcemaps": "latest", "@types/merge2": "latest", "@types/microsoft__typescript-etw": "latest", - "@types/minimatch": "latest", "@types/minimist": "latest", "@types/mkdirp": "latest", "@types/mocha": "latest", "@types/ms": "latest", "@types/node": "latest", "@types/node-fetch": "^2.6.2", - "@types/q": "latest", "@types/source-map-support": "latest", "@types/xml2js": "^0.4.11", "@typescript-eslint/eslint-plugin": "^5.28.0", @@ -59,7 +56,6 @@ "azure-devops-node-api": "^11.1.1", "chai": "latest", "chalk": "^4.1.2", - "convert-source-map": "latest", "del": "6.1.1", "diff": "^5.1.0", "eslint": "8.17.0", @@ -84,11 +80,9 @@ "ms": "^2.1.3", "node-fetch": "^2.6.7", "prex": "^0.4.7", - "q": "latest", "source-map-support": "latest", "typescript": "^4.5.5", "vinyl": "latest", - "vinyl-sourcemaps-apply": "latest", "which": "^2.0.2", "xml2js": "^0.4.23" }, diff --git a/scripts/build/tests.js b/scripts/build/tests.js index a96877c951848..5c804035ed08c 100644 --- a/scripts/build/tests.js +++ b/scripts/build/tests.js @@ -1,5 +1,4 @@ // @ts-check -const gulp = require("gulp"); const del = require("del"); const fs = require("fs"); const os = require("os"); From 284837d66b0e4675b280e8a2d23a38bb9d5876e4 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Fri, 19 Aug 2022 14:27:26 -0400 Subject: [PATCH 05/16] Fixes for `decorators` property deprecations (#50343) * Change type of deprecated 'decorators' property * fix 'Invalid Arguments' error for create/update constructor in factory * Update deprecation comments * Make 'decorators' optional and 'undefined' * Rename '_decorators' to 'illegalDecorators' * Update baselines --- src/compiler/checker.ts | 2 +- src/compiler/debug.ts | 3 +- src/compiler/factory/nodeFactory.ts | 56 +++--- src/compiler/parser.ts | 68 +++---- src/compiler/types.ts | 34 ++-- src/compiler/utilities.ts | 2 +- .../4.8/mergeDecoratorsAndModifiers.ts | 187 ++++++------------ .../convertParamsToDestructuredObject.ts | 2 +- src/testRunner/unittests/factory.ts | 35 ++++ .../reference/api/tsserverlibrary.d.ts | 176 ++++++----------- tests/baselines/reference/api/typescript.d.ts | 176 ++++++----------- 11 files changed, 301 insertions(+), 440 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e2594f6592c14..939f82cca0ad9 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -44030,7 +44030,7 @@ namespace ts { } function checkGrammarDecorators(node: Node): boolean { - if (canHaveIllegalDecorators(node) && some(node.decorators)) { + if (canHaveIllegalDecorators(node) && some(node.illegalDecorators)) { return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here); } if (!canHaveDecorators(node) || !hasDecorators(node)) { diff --git a/src/compiler/debug.ts b/src/compiler/debug.ts index 4f9d8dd554304..c48b1114cb4a1 100644 --- a/src/compiler/debug.ts +++ b/src/compiler/debug.ts @@ -30,6 +30,7 @@ namespace ts { export let currentLogLevel = LogLevel.Warning; export let isDebugging = false; export let loggingHost: LoggingHost | undefined; + export let enableDeprecationWarnings = true; /* eslint-enable prefer-const */ type AssertionKeys = MatchingKeys; @@ -732,7 +733,7 @@ namespace ts { function createWarningDeprecation(name: string, errorAfter: Version | undefined, since: Version | undefined, message: string | undefined) { let hasWrittenDeprecation = false; return () => { - if (!hasWrittenDeprecation) { + if (enableDeprecationWarnings && !hasWrittenDeprecation) { log.warn(formatDeprecationMessage(name, /*error*/ false, errorAfter, since, message)); hasWrittenDeprecation = true; } diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts index d33559a8a1e4d..399dfd9d64640 100644 --- a/src/compiler/factory/nodeFactory.ts +++ b/src/compiler/factory/nodeFactory.ts @@ -1435,7 +1435,7 @@ namespace ts { node.transformFlags = propagateChildFlags(body) | TransformFlags.ContainsClassFields; // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; node.modifiers = undefined; return node; } @@ -1452,7 +1452,7 @@ namespace ts { function finishUpdateClassStaticBlockDeclaration(updated: Mutable, original: ClassStaticBlockDeclaration) { if (updated !== original) { - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; updated.modifiers = original.modifiers; } return update(updated, original); @@ -1476,7 +1476,7 @@ namespace ts { node.transformFlags |= TransformFlags.ContainsES2015; // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; node.typeParameters = undefined; node.type = undefined; return node; @@ -1498,7 +1498,7 @@ namespace ts { function finishUpdateConstructorDeclaration(updated: Mutable, original: ConstructorDeclaration) { if (updated !== original) { - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; updated.typeParameters = original.typeParameters; updated.type = original.type; } @@ -3657,7 +3657,7 @@ namespace ts { } // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; return node; } @@ -3686,7 +3686,7 @@ namespace ts { function finishUpdateFunctionDeclaration(updated: Mutable, original: FunctionDeclaration) { if (updated !== original) { // copy children used only for error reporting - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; } return finishUpdateBaseSignatureDeclaration(updated, original); } @@ -3756,7 +3756,7 @@ namespace ts { node.transformFlags = TransformFlags.ContainsTypeScript; // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; return node; } @@ -3780,7 +3780,7 @@ namespace ts { function finishUpdateInterfaceDeclaration(updated: Mutable, original: InterfaceDeclaration) { if (updated !== original) { - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; } return update(updated, original); } @@ -3802,7 +3802,7 @@ namespace ts { node.transformFlags = TransformFlags.ContainsTypeScript; // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; return node; } @@ -3824,7 +3824,7 @@ namespace ts { function finishUpdateTypeAliasDeclaration(updated: Mutable, original: TypeAliasDeclaration) { if (updated !== original) { - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; } return update(updated, original); } @@ -3847,7 +3847,7 @@ namespace ts { node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // Enum declarations cannot contain `await` // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; return node; } @@ -3866,7 +3866,7 @@ namespace ts { function finishUpdateEnumDeclaration(updated: Mutable, original: EnumDeclaration) { if (updated !== original) { - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; } return update(updated, original); } @@ -3896,7 +3896,7 @@ namespace ts { node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // Module declarations cannot contain `await`. // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; return node; } @@ -3916,7 +3916,7 @@ namespace ts { function finishUpdateModuleDeclaration(updated: Mutable, original: ModuleDeclaration) { if (updated !== original) { - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; } return update(updated, original); } @@ -3961,7 +3961,7 @@ namespace ts { node.transformFlags = TransformFlags.ContainsTypeScript; // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; node.modifiers = undefined; return node; } @@ -3975,7 +3975,7 @@ namespace ts { function finishUpdateNamespaceExportDeclaration(updated: Mutable, original: NamespaceExportDeclaration) { if (updated !== original) { - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; updated.modifiers = original.modifiers; } return update(updated, original); @@ -4000,7 +4000,7 @@ namespace ts { node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // Import= declaration is always parsed in an Await context // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; return node; } @@ -4022,7 +4022,7 @@ namespace ts { function finishUpdateImportEqualsDeclaration(updated: Mutable, original: ImportEqualsDeclaration) { if (updated !== original) { - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; } return update(updated, original); } @@ -4045,7 +4045,7 @@ namespace ts { node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; return node; } @@ -4067,7 +4067,7 @@ namespace ts { function finishUpdateImportDeclaration(updated: Mutable, original: ImportDeclaration) { if (updated !== original) { - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; } return update(updated, original); } @@ -4235,7 +4235,7 @@ namespace ts { node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; return node; } @@ -4253,7 +4253,7 @@ namespace ts { function finishUpdateExportAssignment(updated: Mutable, original: ExportAssignment) { if (updated !== original) { - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; } return update(updated, original); } @@ -4279,7 +4279,7 @@ namespace ts { node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; return node; } @@ -4303,7 +4303,7 @@ namespace ts { function finishUpdateExportDeclaration(updated: Mutable, original: ExportDeclaration) { if (updated !== original) { - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; } return update(updated, original); } @@ -5162,7 +5162,7 @@ namespace ts { propagateChildFlags(node.initializer); // The following properties are used only to report grammar errors - node.decorators = undefined; + node.illegalDecorators = undefined; node.modifiers = undefined; node.questionToken = undefined; node.exclamationToken = undefined; @@ -5180,7 +5180,7 @@ namespace ts { function finishUpdatePropertyAssignment(updated: Mutable, original: PropertyAssignment) { // copy children used only for error reporting if (updated !== original) { - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; updated.modifiers = original.modifiers; updated.questionToken = original.questionToken; updated.exclamationToken = original.exclamationToken; @@ -5202,7 +5202,7 @@ namespace ts { // The following properties are used only to report grammar errors node.equalsToken = undefined; - node.decorators = undefined; + node.illegalDecorators = undefined; node.modifiers = undefined; node.questionToken = undefined; node.exclamationToken = undefined; @@ -5221,7 +5221,7 @@ namespace ts { if (updated !== original) { // copy children used only for error reporting updated.equalsToken = original.equalsToken; - updated.decorators = original.decorators; + updated.illegalDecorators = original.illegalDecorators; updated.modifiers = original.modifiers; updated.questionToken = original.questionToken; updated.exclamationToken = original.exclamationToken; diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index e30a73e093503..b6913a31b0d18 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -123,7 +123,7 @@ namespace ts { visitNode(cbNode, (node as TypeParameterDeclaration).default) || visitNode(cbNode, (node as TypeParameterDeclaration).expression); case SyntaxKind.ShorthandPropertyAssignment: - return visitNodes(cbNode, cbNodes, (node as ShorthandPropertyAssignment).decorators) || + return visitNodes(cbNode, cbNodes, (node as ShorthandPropertyAssignment).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as ShorthandPropertyAssignment).modifiers) || visitNode(cbNode, (node as ShorthandPropertyAssignment).name) || visitNode(cbNode, (node as ShorthandPropertyAssignment).questionToken) || @@ -153,7 +153,7 @@ namespace ts { visitNode(cbNode, (node as PropertySignature).type) || visitNode(cbNode, (node as PropertySignature).initializer); case SyntaxKind.PropertyAssignment: - return visitNodes(cbNode, cbNodes, (node as PropertyAssignment).decorators) || + return visitNodes(cbNode, cbNodes, (node as PropertyAssignment).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as PropertyAssignment).modifiers) || visitNode(cbNode, (node as PropertyAssignment).name) || visitNode(cbNode, (node as PropertyAssignment).questionToken) || @@ -170,7 +170,7 @@ namespace ts { visitNode(cbNode, (node as BindingElement).name) || visitNode(cbNode, (node as BindingElement).initializer); case SyntaxKind.IndexSignature: - return visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).modifiers) || visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).typeParameters) || visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).parameters) || @@ -208,7 +208,7 @@ namespace ts { visitNodes(cbNode, cbNodes, (node as MethodSignature).parameters) || visitNode(cbNode, (node as MethodSignature).type); case SyntaxKind.Constructor: - return visitNodes(cbNode, cbNodes, (node as ConstructorDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as ConstructorDeclaration).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as ConstructorDeclaration).modifiers) || visitNode(cbNode, (node as ConstructorDeclaration).name) || visitNodes(cbNode, cbNodes, (node as ConstructorDeclaration).typeParameters) || @@ -230,7 +230,7 @@ namespace ts { visitNode(cbNode, (node as SetAccessorDeclaration).type) || visitNode(cbNode, (node as SetAccessorDeclaration).body); case SyntaxKind.FunctionDeclaration: - return visitNodes(cbNode, cbNodes, (node as FunctionDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as FunctionDeclaration).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as FunctionDeclaration).modifiers) || visitNode(cbNode, (node as FunctionDeclaration).asteriskToken) || visitNode(cbNode, (node as FunctionDeclaration).name) || @@ -254,7 +254,7 @@ namespace ts { visitNode(cbNode, (node as ArrowFunction).equalsGreaterThanToken) || visitNode(cbNode, (node as ArrowFunction).body); case SyntaxKind.ClassStaticBlockDeclaration: - return visitNodes(cbNode, cbNodes, (node as ClassStaticBlockDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as ClassStaticBlockDeclaration).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as ClassStaticBlockDeclaration).modifiers) || visitNode(cbNode, (node as ClassStaticBlockDeclaration).body); case SyntaxKind.TypeReference: @@ -382,7 +382,7 @@ namespace ts { return visitNodes(cbNode, cbNodes, (node as SourceFile).statements) || visitNode(cbNode, (node as SourceFile).endOfFileToken); case SyntaxKind.VariableStatement: - return visitNodes(cbNode, cbNodes, (node as VariableStatement).decorators) || + return visitNodes(cbNode, cbNodes, (node as VariableStatement).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as VariableStatement).modifiers) || visitNode(cbNode, (node as VariableStatement).declarationList); case SyntaxKind.VariableDeclarationList: @@ -453,20 +453,20 @@ namespace ts { visitNodes(cbNode, cbNodes, (node as ClassLikeDeclaration).heritageClauses) || visitNodes(cbNode, cbNodes, (node as ClassLikeDeclaration).members); case SyntaxKind.InterfaceDeclaration: - return visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).modifiers) || visitNode(cbNode, (node as InterfaceDeclaration).name) || visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).typeParameters) || visitNodes(cbNode, cbNodes, (node as ClassDeclaration).heritageClauses) || visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).members); case SyntaxKind.TypeAliasDeclaration: - return visitNodes(cbNode, cbNodes, (node as TypeAliasDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as TypeAliasDeclaration).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as TypeAliasDeclaration).modifiers) || visitNode(cbNode, (node as TypeAliasDeclaration).name) || visitNodes(cbNode, cbNodes, (node as TypeAliasDeclaration).typeParameters) || visitNode(cbNode, (node as TypeAliasDeclaration).type); case SyntaxKind.EnumDeclaration: - return visitNodes(cbNode, cbNodes, (node as EnumDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as EnumDeclaration).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as EnumDeclaration).modifiers) || visitNode(cbNode, (node as EnumDeclaration).name) || visitNodes(cbNode, cbNodes, (node as EnumDeclaration).members); @@ -474,17 +474,17 @@ namespace ts { return visitNode(cbNode, (node as EnumMember).name) || visitNode(cbNode, (node as EnumMember).initializer); case SyntaxKind.ModuleDeclaration: - return visitNodes(cbNode, cbNodes, (node as ModuleDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as ModuleDeclaration).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as ModuleDeclaration).modifiers) || visitNode(cbNode, (node as ModuleDeclaration).name) || visitNode(cbNode, (node as ModuleDeclaration).body); case SyntaxKind.ImportEqualsDeclaration: - return visitNodes(cbNode, cbNodes, (node as ImportEqualsDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as ImportEqualsDeclaration).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as ImportEqualsDeclaration).modifiers) || visitNode(cbNode, (node as ImportEqualsDeclaration).name) || visitNode(cbNode, (node as ImportEqualsDeclaration).moduleReference); case SyntaxKind.ImportDeclaration: - return visitNodes(cbNode, cbNodes, (node as ImportDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as ImportDeclaration).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as ImportDeclaration).modifiers) || visitNode(cbNode, (node as ImportDeclaration).importClause) || visitNode(cbNode, (node as ImportDeclaration).moduleSpecifier) || @@ -498,7 +498,7 @@ namespace ts { return visitNode(cbNode, (node as AssertEntry).name) || visitNode(cbNode, (node as AssertEntry).value); case SyntaxKind.NamespaceExportDeclaration: - return visitNodes(cbNode, cbNodes, (node as NamespaceExportDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as NamespaceExportDeclaration).illegalDecorators) || visitNode(cbNode, (node as NamespaceExportDeclaration).name); case SyntaxKind.NamespaceImport: return visitNode(cbNode, (node as NamespaceImport).name); @@ -508,7 +508,7 @@ namespace ts { case SyntaxKind.NamedExports: return visitNodes(cbNode, cbNodes, (node as NamedImportsOrExports).elements); case SyntaxKind.ExportDeclaration: - return visitNodes(cbNode, cbNodes, (node as ExportDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as ExportDeclaration).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as ExportDeclaration).modifiers) || visitNode(cbNode, (node as ExportDeclaration).exportClause) || visitNode(cbNode, (node as ExportDeclaration).moduleSpecifier) || @@ -518,7 +518,7 @@ namespace ts { return visitNode(cbNode, (node as ImportOrExportSpecifier).propertyName) || visitNode(cbNode, (node as ImportOrExportSpecifier).name); case SyntaxKind.ExportAssignment: - return visitNodes(cbNode, cbNodes, (node as ExportAssignment).decorators) || + return visitNodes(cbNode, cbNodes, (node as ExportAssignment).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as ExportAssignment).modifiers) || visitNode(cbNode, (node as ExportAssignment).expression); case SyntaxKind.TemplateExpression: @@ -543,7 +543,7 @@ namespace ts { case SyntaxKind.ExternalModuleReference: return visitNode(cbNode, (node as ExternalModuleReference).expression); case SyntaxKind.MissingDeclaration: - return visitNodes(cbNode, cbNodes, (node as MissingDeclaration).decorators) || + return visitNodes(cbNode, cbNodes, (node as MissingDeclaration).illegalDecorators) || visitNodes(cbNode, cbNodes, (node as MissingDeclaration).modifiers); case SyntaxKind.CommaListExpression: return visitNodes(cbNode, cbNodes, (node as CommaListExpression).elements); @@ -3560,7 +3560,7 @@ namespace ts { const type = parseTypeAnnotation(); parseTypeMemberSemicolon(); const node = factory.createIndexSignature(modifiers, parameters, type); - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; return withJSDoc(finishNode(node, pos), hasJSDoc); } @@ -5974,7 +5974,7 @@ namespace ts { node = factory.createPropertyAssignment(name, initializer); } // Decorators, Modifiers, questionToken, and exclamationToken are not supported by property assignments and are reported in the grammar checker - node.decorators = decorators; + node.illegalDecorators = decorators; node.modifiers = modifiers; node.questionToken = questionToken; node.exclamationToken = exclamationToken; @@ -6694,7 +6694,7 @@ namespace ts { // would follow. For recovery and error reporting purposes, return an incomplete declaration. const missing = createMissingNode(SyntaxKind.MissingDeclaration, /*reportAtCurrentPosition*/ true, Diagnostics.Declaration_expected); setTextRangePos(missing, pos); - missing.decorators = decorators; + missing.illegalDecorators = decorators; missing.modifiers = modifiers; return missing; } @@ -6858,7 +6858,7 @@ namespace ts { parseSemicolon(); const node = factory.createVariableStatement(modifiers, declarationList); // Decorators are not allowed on a variable statement, so we keep track of them to report them in the grammar checker. - node.decorators = decorators; + node.illegalDecorators = decorators; return withJSDoc(finishNode(node, pos), hasJSDoc); } @@ -6879,7 +6879,7 @@ namespace ts { const body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, Diagnostics.or_expected); setAwaitContext(savedAwaitContext); const node = factory.createFunctionDeclaration(modifiers, asteriskToken, name, typeParameters, parameters, type, body); - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; return withJSDoc(finishNode(node, pos), hasJSDoc); } @@ -6905,7 +6905,7 @@ namespace ts { const node = factory.createConstructorDeclaration(modifiers, parameters, body); // Attach invalid nodes if they exist so that we can report them in the grammar checker. - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; (node as Mutable).typeParameters = typeParameters; (node as Mutable).type = type; return withJSDoc(finishNode(node, pos), hasJSDoc); @@ -7072,7 +7072,7 @@ namespace ts { parseExpectedToken(SyntaxKind.StaticKeyword); const body = parseClassStaticBlockBody(); const node = withJSDoc(finishNode(factory.createClassStaticBlockDeclaration(body), pos), hasJSDoc); - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; (node as Mutable).modifiers = modifiers; return node; } @@ -7347,7 +7347,7 @@ namespace ts { const heritageClauses = parseHeritageClauses(); const members = parseObjectTypeMembers(); const node = factory.createInterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, members); - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; return withJSDoc(finishNode(node, pos), hasJSDoc); } @@ -7359,7 +7359,7 @@ namespace ts { const type = token() === SyntaxKind.IntrinsicKeyword && tryParse(parseKeywordAndNoDot) || parseType(); parseSemicolon(); const node = factory.createTypeAliasDeclaration(modifiers, name, typeParameters, type); - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; return withJSDoc(finishNode(node, pos), hasJSDoc); } @@ -7387,7 +7387,7 @@ namespace ts { members = createMissingList(); } const node = factory.createEnumDeclaration(modifiers, name, members); - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; return withJSDoc(finishNode(node, pos), hasJSDoc); } @@ -7413,7 +7413,7 @@ namespace ts { ? parseModuleOrNamespaceDeclaration(getNodePos(), /*hasJSDoc*/ false, /*decorators*/ undefined, /*modifiers*/ undefined, NodeFlags.NestedNamespace | namespaceFlag) as NamespaceDeclaration : parseModuleBlock(); const node = factory.createModuleDeclaration(modifiers, name, body, flags); - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; return withJSDoc(finishNode(node, pos), hasJSDoc); } @@ -7437,7 +7437,7 @@ namespace ts { parseSemicolon(); } const node = factory.createModuleDeclaration(modifiers, name, body, flags); - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; return withJSDoc(finishNode(node, pos), hasJSDoc); } @@ -7483,7 +7483,7 @@ namespace ts { parseSemicolon(); const node = factory.createNamespaceExportDeclaration(name); // NamespaceExportDeclaration nodes cannot have decorators or modifiers, so we attach them here so we can report them in the grammar checker - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; (node as Mutable).modifiers = modifiers; return withJSDoc(finishNode(node, pos), hasJSDoc); } @@ -7532,7 +7532,7 @@ namespace ts { parseSemicolon(); const node = factory.createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause); - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; return withJSDoc(finishNode(node, pos), hasJSDoc); } @@ -7585,7 +7585,7 @@ namespace ts { const moduleReference = parseModuleReference(); parseSemicolon(); const node = factory.createImportEqualsDeclaration(modifiers, isTypeOnly, identifier, moduleReference); - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; const finished = withJSDoc(finishNode(node, pos), hasJSDoc); return finished; } @@ -7794,7 +7794,7 @@ namespace ts { parseSemicolon(); setAwaitContext(savedAwaitContext); const node = factory.createExportDeclaration(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause); - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; return withJSDoc(finishNode(node, pos), hasJSDoc); } @@ -7812,7 +7812,7 @@ namespace ts { parseSemicolon(); setAwaitContext(savedAwaitContext); const node = factory.createExportAssignment(modifiers, isExportEquals, expression); - (node as Mutable).decorators = decorators; + (node as Mutable).illegalDecorators = decorators; return withJSDoc(finishNode(node, pos), hasJSDoc); } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 68af5c8860b8d..45b66261eb46e 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1622,7 +1622,7 @@ namespace ts { readonly initializer: Expression; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; // property assignment cannot have decorators + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; // property assignment cannot have decorators /* @internal */ readonly modifiers?: NodeArray | undefined; // property assignment cannot have modifiers /* @internal */ readonly questionToken?: QuestionToken | undefined; // property assignment cannot have a question token /* @internal */ readonly exclamationToken?: ExclamationToken | undefined; // property assignment cannot have an exclamation token @@ -1638,7 +1638,7 @@ namespace ts { readonly objectAssignmentInitializer?: Expression; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; // shorthand property assignment cannot have decorators + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; // shorthand property assignment cannot have decorators /* @internal */ readonly modifiers?: NodeArray | undefined; // shorthand property assignment cannot have modifiers /* @internal */ readonly questionToken?: QuestionToken | undefined; // shorthand property assignment cannot have a question token /* @internal */ readonly exclamationToken?: ExclamationToken | undefined; // shorthand property assignment cannot have an exclamation token @@ -1720,7 +1720,7 @@ namespace ts { readonly body?: FunctionBody; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; // functions cannot have decorators + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; // functions cannot have decorators } export interface MethodSignature extends SignatureDeclarationBase, TypeElement { @@ -1757,7 +1757,7 @@ namespace ts { readonly body?: FunctionBody | undefined; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; // A constructor cannot have decorators + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; // A constructor cannot have decorators /* @internal */ readonly typeParameters?: NodeArray; // A constructor cannot have type parameters /* @internal */ readonly type?: TypeNode; // A constructor cannot have a return type annotation } @@ -1804,7 +1804,7 @@ namespace ts { readonly type: TypeNode; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; } export interface ClassStaticBlockDeclaration extends ClassElement, JSDocContainer { @@ -1816,7 +1816,7 @@ namespace ts { /* @internal */ returnFlowNode?: FlowNode; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; /* @internal */ readonly modifiers?: NodeArray | undefined; } @@ -2966,7 +2966,7 @@ namespace ts { readonly name?: Identifier; // The following properties are used only to report grammar errors - /*@internal*/ decorators?: NodeArray | undefined; + /*@internal*/ illegalDecorators?: NodeArray | undefined; /*@internal*/ modifiers?: NodeArray | undefined; } @@ -2989,7 +2989,7 @@ namespace ts { readonly declarationList: VariableDeclarationList; // The following properties are used only to report grammar errors - /* @internal*/ decorators?: NodeArray | undefined; + /* @internal*/ illegalDecorators?: NodeArray | undefined; } export interface ExpressionStatement extends Statement { @@ -3203,7 +3203,7 @@ namespace ts { readonly members: NodeArray; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; } export interface HeritageClause extends Node { @@ -3221,7 +3221,7 @@ namespace ts { readonly type: TypeNode; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; } export interface EnumMember extends NamedDeclaration, JSDocContainer { @@ -3240,7 +3240,7 @@ namespace ts { readonly members: NodeArray; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; } export type ModuleName = @@ -3266,7 +3266,7 @@ namespace ts { readonly body?: ModuleBody | JSDocNamespaceDeclaration; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; } export type NamespaceBody = @@ -3317,7 +3317,7 @@ namespace ts { readonly moduleReference: ModuleReference; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; } export interface ExternalModuleReference extends Node { @@ -3340,7 +3340,7 @@ namespace ts { readonly assertClause?: AssertClause; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; } export type NamedImportBindings = @@ -3400,7 +3400,7 @@ namespace ts { readonly name: Identifier; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; /* @internal */ readonly modifiers?: NodeArray | undefined; } @@ -3416,7 +3416,7 @@ namespace ts { readonly assertClause?: AssertClause; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; } export interface NamedImports extends Node { @@ -3481,7 +3481,7 @@ namespace ts { readonly expression: Expression; // The following properties are used only to report grammar errors - /* @internal */ readonly decorators?: NodeArray | undefined; + /* @internal */ readonly illegalDecorators?: NodeArray | undefined; } export interface FileReference extends TextRange { diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index cc911b946d444..62a941df1f79f 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -7542,7 +7542,7 @@ namespace ts { case SyntaxKind.Decorator: { const { parent } = node as Decorator; return canHaveDecorators(parent) ? parent.modifiers : - canHaveIllegalDecorators(parent) ? parent.decorators : + canHaveIllegalDecorators(parent) ? parent.illegalDecorators : undefined; } case SyntaxKind.HeritageClause: diff --git a/src/deprecatedCompat/4.8/mergeDecoratorsAndModifiers.ts b/src/deprecatedCompat/4.8/mergeDecoratorsAndModifiers.ts index 908cdf5c275a5..d6cdbf2969e1c 100644 --- a/src/deprecatedCompat/4.8/mergeDecoratorsAndModifiers.ts +++ b/src/deprecatedCompat/4.8/mergeDecoratorsAndModifiers.ts @@ -5,10 +5,28 @@ // - error: 5.0 namespace ts { export interface Node { - /** @deprecated `decorators` has been merged with `modifiers` on the declarations that support decorators. */ - readonly decorators?: NodeArray | undefined; + /** + * @deprecated `decorators` has been removed from `Node` and merged with `modifiers` on the `Node` subtypes that support them. + * Use `ts.canHaveDecorators()` to test whether a `Node` can have decorators. + * Use `ts.getDecorators()` to get the decorators of a `Node`. + * + * For example: + * ```ts + * const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined; + * ``` + */ + readonly decorators?: undefined; - /** @deprecated `modifiers` has been removed from `Node` and moved to the specific `Node` subtypes that support them. */ + /** + * @deprecated `modifiers` has been removed from `Node` and moved to the `Node` subtypes that support them. + * Use `ts.canHaveModifiers()` to test whether a `Node` can have modifiers. + * Use `ts.getModifiers()` to get the modifiers of a `Node`. + * + * For example: + * ```ts + * const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined; + * ``` + */ readonly modifiers?: NodeArray | undefined; } @@ -43,239 +61,162 @@ namespace ts { export interface NodeFactory { /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createParameterDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateParameterDeclaration(node: ParameterDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createPropertyDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updatePropertyDeclaration(node: PropertyDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createMethodDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateMethodDeclaration(node: MethodDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter. */ createConstructorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter. */ updateConstructorDeclaration(node: ConstructorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createGetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateGetAccessorDeclaration(node: GetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createSetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateSetAccessorDeclaration(node: SetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators and modifiers are no longer supported for this function. Callers should use an overload that does not accept the `decorators` and `modifiers` parameters. */ updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators and modifiers are no longer supported for this function. Callers should use an overload that does not accept the `decorators` and `modifiers` parameters. */ createClassStaticBlockDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createClassExpression(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateClassExpression(node: ClassExpression, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createFunctionDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateFunctionDeclaration(node: FunctionDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createClassDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateClassDeclaration(node: ClassDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createInterfaceDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateInterfaceDeclaration(node: InterfaceDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createTypeAliasDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateTypeAliasDeclaration(node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createModuleDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateModuleDeclaration(node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createImportEqualsDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createImportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause): ImportDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateImportDeclaration(node: ImportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createExportAssignment(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateExportAssignment(node: ExportAssignment, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createExportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression, assertClause?: AssertClause): ExportDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateExportDeclaration(node: ExportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, assertClause: AssertClause | undefined): ExportDeclaration; - } - const MUST_MERGE: DeprecationOptions = { since: "4.8", warnAfter: "4.9.0-0", message: "Decorators have been combined with modifiers. Callers should switch to an overload without a 'decorators' parameter." }; - const DISALLOW_DECORATORS: DeprecationOptions = { since: "4.8", warnAfter: "4.9.0-0", message: `Decorators are no longer supported for this function. Callers should switch to an overload without a 'decorators' parameter.` }; - const DISALLOW_DECORATORS_AND_MODIFIERS: DeprecationOptions = { since: "4.8", warnAfter: "4.9.0-0", message: `Decorators and modifiers are no longer supported for this function. Callers should switch to an overload without the 'decorators' or 'modifiers' parameters.` }; + const MUST_MERGE: DeprecationOptions = { since: "4.8", warnAfter: "4.9.0-0", message: "Decorators have been combined with modifiers. Callers should switch to an overload that does not accept a 'decorators' parameter." }; + const DISALLOW_DECORATORS: DeprecationOptions = { since: "4.8", warnAfter: "4.9.0-0", message: `Decorators are no longer supported for this function. Callers should switch to an overload that does not accept a 'decorators' parameter.` }; + const DISALLOW_DECORATORS_AND_MODIFIERS: DeprecationOptions = { since: "4.8", warnAfter: "4.9.0-0", message: `Decorators and modifiers are no longer supported for this function. Callers should switch to an overload that does not accept the 'decorators' and 'modifiers' parameters.` }; function patchNodeFactory(factory: NodeFactory) { const { @@ -535,7 +476,7 @@ namespace ts { (decorators === undefined || !some(decorators, isModifier)) && (modifiers === undefined || !some(modifiers, isParameter)) && (parameters === undefined || isArray(parameters)) && - (body === undefined || !isBlock(body)), + (body === undefined || isBlock(body)), }) .deprecate({ 1: DISALLOW_DECORATORS @@ -563,7 +504,7 @@ namespace ts { (decorators === undefined || !some(decorators, isModifier)) && (modifiers === undefined || !some(modifiers, isParameter)) && (parameters === undefined || isArray(parameters)) && - (body === undefined || !isBlock(body)), + (body === undefined || isBlock(body)), }) .deprecate({ 1: DISALLOW_DECORATORS diff --git a/src/services/refactors/convertParamsToDestructuredObject.ts b/src/services/refactors/convertParamsToDestructuredObject.ts index 4c6f4f617896c..015960707ee49 100644 --- a/src/services/refactors/convertParamsToDestructuredObject.ts +++ b/src/services/refactors/convertParamsToDestructuredObject.ts @@ -653,7 +653,7 @@ namespace ts.refactor.convertParamsToDestructuredObject { interface ValidParameterDeclaration extends ParameterDeclaration { name: Identifier; modifiers: undefined; - decorators: undefined; + illegalDecorators: undefined; } interface GroupedReferences { diff --git a/src/testRunner/unittests/factory.ts b/src/testRunner/unittests/factory.ts index 9bf9feda8744d..93c34c520a712 100644 --- a/src/testRunner/unittests/factory.ts +++ b/src/testRunner/unittests/factory.ts @@ -81,5 +81,40 @@ namespace ts { checkRhs(SyntaxKind.QuestionQuestionEqualsToken, /*expectParens*/ false); }); }); + + describe("deprecations", () => { + beforeEach(() => { + Debug.enableDeprecationWarnings = false; + }); + + afterEach(() => { + Debug.enableDeprecationWarnings = true; + }); + + // https://github.com/microsoft/TypeScript/issues/50259 + it("deprecated createConstructorDeclaration overload does not throw", () => { + const body = factory.createBlock([]); + assert.doesNotThrow(() => factory.createConstructorDeclaration( + /*decorators*/ undefined, + /*modifiers*/ undefined, + /*parameters*/ [], + body, + )); + }); + + // https://github.com/microsoft/TypeScript/issues/50259 + it("deprecated updateConstructorDeclaration overload does not throw", () => { + const body = factory.createBlock([]); + const ctor = factory.createConstructorDeclaration(/*modifiers*/ undefined, [], body); + assert.doesNotThrow(() => factory.updateConstructorDeclaration( + ctor, + ctor.decorators, + ctor.modifiers, + ctor.parameters, + ctor.body, + )); + }); + }); + }); } diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 77ddcc8ffceed..05fed42876185 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -11780,9 +11780,27 @@ declare namespace ts { } declare namespace ts { interface Node { - /** @deprecated `decorators` has been merged with `modifiers` on the declarations that support decorators. */ - readonly decorators?: NodeArray | undefined; - /** @deprecated `modifiers` has been removed from `Node` and moved to the specific `Node` subtypes that support them. */ + /** + * @deprecated `decorators` has been removed from `Node` and merged with `modifiers` on the `Node` subtypes that support them. + * Use `ts.canHaveDecorators()` to test whether a `Node` can have decorators. + * Use `ts.getDecorators()` to get the decorators of a `Node`. + * + * For example: + * ```ts + * const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined; + * ``` + */ + readonly decorators?: undefined; + /** + * @deprecated `modifiers` has been removed from `Node` and moved to the `Node` subtypes that support them. + * Use `ts.canHaveModifiers()` to test whether a `Node` can have modifiers. + * Use `ts.getModifiers()` to get the modifiers of a `Node`. + * + * For example: + * ```ts + * const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined; + * ``` + */ readonly modifiers?: NodeArray | undefined; } interface PropertySignature { @@ -11809,231 +11827,155 @@ declare namespace ts { } interface NodeFactory { /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createParameterDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateParameterDeclaration(node: ParameterDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createPropertyDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updatePropertyDeclaration(node: PropertyDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createMethodDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateMethodDeclaration(node: MethodDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter. */ createConstructorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter. */ updateConstructorDeclaration(node: ConstructorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createGetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateGetAccessorDeclaration(node: GetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createSetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateSetAccessorDeclaration(node: SetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators and modifiers are no longer supported for this function. Callers should use an overload that does not accept the `decorators` and `modifiers` parameters. */ updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators and modifiers are no longer supported for this function. Callers should use an overload that does not accept the `decorators` and `modifiers` parameters. */ createClassStaticBlockDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createClassExpression(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateClassExpression(node: ClassExpression, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createFunctionDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateFunctionDeclaration(node: FunctionDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createClassDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateClassDeclaration(node: ClassDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createInterfaceDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateInterfaceDeclaration(node: InterfaceDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createTypeAliasDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateTypeAliasDeclaration(node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createModuleDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateModuleDeclaration(node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createImportEqualsDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createImportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause): ImportDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateImportDeclaration(node: ImportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createExportAssignment(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateExportAssignment(node: ExportAssignment, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createExportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression, assertClause?: AssertClause): ExportDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateExportDeclaration(node: ExportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, assertClause: AssertClause | undefined): ExportDeclaration; } diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 41938960fa8ac..ddaab547b5439 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -7912,9 +7912,27 @@ declare namespace ts { } declare namespace ts { interface Node { - /** @deprecated `decorators` has been merged with `modifiers` on the declarations that support decorators. */ - readonly decorators?: NodeArray | undefined; - /** @deprecated `modifiers` has been removed from `Node` and moved to the specific `Node` subtypes that support them. */ + /** + * @deprecated `decorators` has been removed from `Node` and merged with `modifiers` on the `Node` subtypes that support them. + * Use `ts.canHaveDecorators()` to test whether a `Node` can have decorators. + * Use `ts.getDecorators()` to get the decorators of a `Node`. + * + * For example: + * ```ts + * const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined; + * ``` + */ + readonly decorators?: undefined; + /** + * @deprecated `modifiers` has been removed from `Node` and moved to the `Node` subtypes that support them. + * Use `ts.canHaveModifiers()` to test whether a `Node` can have modifiers. + * Use `ts.getModifiers()` to get the modifiers of a `Node`. + * + * For example: + * ```ts + * const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined; + * ``` + */ readonly modifiers?: NodeArray | undefined; } interface PropertySignature { @@ -7941,231 +7959,155 @@ declare namespace ts { } interface NodeFactory { /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createParameterDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateParameterDeclaration(node: ParameterDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createPropertyDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updatePropertyDeclaration(node: PropertyDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createMethodDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateMethodDeclaration(node: MethodDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter. */ createConstructorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter. */ updateConstructorDeclaration(node: ConstructorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createGetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateGetAccessorDeclaration(node: GetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createSetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateSetAccessorDeclaration(node: SetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators and modifiers are no longer supported for this function. Callers should use an overload that does not accept the `decorators` and `modifiers` parameters. */ updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators and modifiers are no longer supported for this function. Callers should use an overload that does not accept the `decorators` and `modifiers` parameters. */ createClassStaticBlockDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createClassExpression(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateClassExpression(node: ClassExpression, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createFunctionDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateFunctionDeclaration(node: FunctionDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ createClassDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter. */ updateClassDeclaration(node: ClassDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createInterfaceDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateInterfaceDeclaration(node: InterfaceDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createTypeAliasDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateTypeAliasDeclaration(node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createModuleDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateModuleDeclaration(node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createImportEqualsDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createImportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause): ImportDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateImportDeclaration(node: ImportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createExportAssignment(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateExportAssignment(node: ExportAssignment, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ createExportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression, assertClause?: AssertClause): ExportDeclaration; /** - * @deprecated Decorators have been combined with modifiers. Callers should pass - * `null` to the `decorators` parameter so that a future update can introduce - * an overload that removes the parameter entirely. + * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter. */ updateExportDeclaration(node: ExportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, assertClause: AssertClause | undefined): ExportDeclaration; } From 6cbb39ba8b8846f36dbe34d9a55aca08be2c6e1e Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 19 Aug 2022 12:58:54 -0700 Subject: [PATCH 06/16] Re-caret dependencies so deps like eslint continue to be bumped (#50368) --- package-lock.json | 114 ++++++++++++++++++++++++++++++---------------- package.json | 22 ++++----- 2 files changed, 86 insertions(+), 50 deletions(-) diff --git a/package-lock.json b/package-lock.json index 1949d70b207e5..3f8d272cbb370 100644 --- a/package-lock.json +++ b/package-lock.json @@ -33,20 +33,20 @@ "@types/node-fetch": "^2.6.2", "@types/source-map-support": "latest", "@types/xml2js": "^0.4.11", - "@typescript-eslint/eslint-plugin": "^5.28.0", - "@typescript-eslint/parser": "^5.28.0", - "@typescript-eslint/utils": "^5.28.0", + "@typescript-eslint/eslint-plugin": "^5.33.1", + "@typescript-eslint/parser": "^5.33.1", + "@typescript-eslint/utils": "^5.33.1", "async": "latest", - "azure-devops-node-api": "^11.1.1", + "azure-devops-node-api": "^11.2.0", "chai": "latest", "chalk": "^4.1.2", - "del": "6.1.1", + "del": "^6.1.1", "diff": "^5.1.0", - "eslint": "8.17.0", - "eslint-formatter-autolinkable-stylish": "1.2.0", - "eslint-plugin-import": "2.26.0", - "eslint-plugin-jsdoc": "39.3.2", - "eslint-plugin-no-null": "1.0.2", + "eslint": "^8.22.0", + "eslint-formatter-autolinkable-stylish": "^1.2.0", + "eslint-plugin-import": "^2.26.0", + "eslint-plugin-jsdoc": "^39.3.6", + "eslint-plugin-no-null": "^1.0.2", "fancy-log": "latest", "fs-extra": "^9.1.0", "glob": "latest", @@ -65,7 +65,7 @@ "node-fetch": "^2.6.7", "prex": "^0.4.7", "source-map-support": "latest", - "typescript": "^4.5.5", + "typescript": "^4.7.4", "vinyl": "latest", "which": "^2.0.2", "xml2js": "^0.4.23" @@ -217,9 +217,9 @@ } }, "node_modules/@humanwhocodes/config-array": { - "version": "0.9.5", - "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.9.5.tgz", - "integrity": "sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw==", + "version": "0.10.4", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.10.4.tgz", + "integrity": "sha512-mXAIHxZT3Vcpg83opl1wGlVZ9xydbfZO3r5YfRSH6Gpp2J/PfdBP0wbDa2sO6/qRbcalpoevVyW6A/fI6LfeMw==", "dev": true, "dependencies": { "@humanwhocodes/object-schema": "^1.2.1", @@ -230,6 +230,16 @@ "node": ">=10.10.0" } }, + "node_modules/@humanwhocodes/gitignore-to-minimatch": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@humanwhocodes/gitignore-to-minimatch/-/gitignore-to-minimatch-1.0.2.tgz", + "integrity": "sha512-rSqmMJDdLFUsyxR6FMtD00nfQKKLFb1kv+qBbOVKqErvloEIJLo5bDTJTQNTYgeyp78JsA7u/NPi5jT1GR/MuA==", + "dev": true, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, "node_modules/@humanwhocodes/object-schema": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", @@ -2322,13 +2332,14 @@ } }, "node_modules/eslint": { - "version": "8.17.0", - "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.17.0.tgz", - "integrity": "sha512-gq0m0BTJfci60Fz4nczYxNAlED+sMcihltndR8t9t1evnU/azx53x3t2UHXC/uRjcbvRw/XctpaNygSTcQD+Iw==", + "version": "8.22.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.22.0.tgz", + "integrity": "sha512-ci4t0sz6vSRKdmkOGmprBo6fmI4PrphDFMy5JEq/fNS0gQkJM3rLmrqcp8ipMcdobH3KtUP40KniAE9W19S4wA==", "dev": true, "dependencies": { "@eslint/eslintrc": "^1.3.0", - "@humanwhocodes/config-array": "^0.9.2", + "@humanwhocodes/config-array": "^0.10.4", + "@humanwhocodes/gitignore-to-minimatch": "^1.0.2", "ajv": "^6.10.0", "chalk": "^4.0.0", "cross-spawn": "^7.0.2", @@ -2338,14 +2349,17 @@ "eslint-scope": "^7.1.1", "eslint-utils": "^3.0.0", "eslint-visitor-keys": "^3.3.0", - "espree": "^9.3.2", + "espree": "^9.3.3", "esquery": "^1.4.0", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", "functional-red-black-tree": "^1.0.1", "glob-parent": "^6.0.1", "globals": "^13.15.0", + "globby": "^11.1.0", + "grapheme-splitter": "^1.0.4", "ignore": "^5.2.0", "import-fresh": "^3.0.0", "imurmurhash": "^0.1.4", @@ -2489,9 +2503,9 @@ "dev": true }, "node_modules/eslint-plugin-jsdoc": { - "version": "39.3.2", - "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-39.3.2.tgz", - "integrity": "sha512-RSGN94RYzIJS/WfW3l6cXzRLfJWxvJgNQZ4w0WCaxJWDJMigtwTsILEAfKqmmPkT2rwMH/s3C7G5ChDE6cwPJg==", + "version": "39.3.6", + "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-39.3.6.tgz", + "integrity": "sha512-R6dZ4t83qPdMhIOGr7g2QII2pwCjYyKP+z0tPOfO1bbAbQyKC20Y2Rd6z1te86Lq3T7uM8bNo+VD9YFpE8HU/g==", "dev": true, "dependencies": { "@es-joy/jsdoccomment": "~0.31.0", @@ -3272,9 +3286,9 @@ } }, "node_modules/flatted": { - "version": "3.2.6", - "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.6.tgz", - "integrity": "sha512-0sQoMh9s0BYsm+12Huy/rkKxVu4R1+r96YX5cG44rHV0pQ6iC3Q+mkoMFaGWObMFYQxCVT+ssG1ksneA2MI9KQ==", + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz", + "integrity": "sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==", "dev": true }, "node_modules/flush-write-stream": { @@ -3997,6 +4011,12 @@ "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==", "dev": true }, + "node_modules/grapheme-splitter": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz", + "integrity": "sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==", + "dev": true + }, "node_modules/gulp": { "version": "4.0.2", "resolved": "https://registry.npmjs.org/gulp/-/gulp-4.0.2.tgz", @@ -8679,9 +8699,9 @@ } }, "@humanwhocodes/config-array": { - "version": "0.9.5", - "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.9.5.tgz", - "integrity": "sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw==", + "version": "0.10.4", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.10.4.tgz", + "integrity": "sha512-mXAIHxZT3Vcpg83opl1wGlVZ9xydbfZO3r5YfRSH6Gpp2J/PfdBP0wbDa2sO6/qRbcalpoevVyW6A/fI6LfeMw==", "dev": true, "requires": { "@humanwhocodes/object-schema": "^1.2.1", @@ -8689,6 +8709,12 @@ "minimatch": "^3.0.4" } }, + "@humanwhocodes/gitignore-to-minimatch": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@humanwhocodes/gitignore-to-minimatch/-/gitignore-to-minimatch-1.0.2.tgz", + "integrity": "sha512-rSqmMJDdLFUsyxR6FMtD00nfQKKLFb1kv+qBbOVKqErvloEIJLo5bDTJTQNTYgeyp78JsA7u/NPi5jT1GR/MuA==", + "dev": true + }, "@humanwhocodes/object-schema": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", @@ -10347,13 +10373,14 @@ "dev": true }, "eslint": { - "version": "8.17.0", - "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.17.0.tgz", - "integrity": "sha512-gq0m0BTJfci60Fz4nczYxNAlED+sMcihltndR8t9t1evnU/azx53x3t2UHXC/uRjcbvRw/XctpaNygSTcQD+Iw==", + "version": "8.22.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.22.0.tgz", + "integrity": "sha512-ci4t0sz6vSRKdmkOGmprBo6fmI4PrphDFMy5JEq/fNS0gQkJM3rLmrqcp8ipMcdobH3KtUP40KniAE9W19S4wA==", "dev": true, "requires": { "@eslint/eslintrc": "^1.3.0", - "@humanwhocodes/config-array": "^0.9.2", + "@humanwhocodes/config-array": "^0.10.4", + "@humanwhocodes/gitignore-to-minimatch": "^1.0.2", "ajv": "^6.10.0", "chalk": "^4.0.0", "cross-spawn": "^7.0.2", @@ -10363,14 +10390,17 @@ "eslint-scope": "^7.1.1", "eslint-utils": "^3.0.0", "eslint-visitor-keys": "^3.3.0", - "espree": "^9.3.2", + "espree": "^9.3.3", "esquery": "^1.4.0", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", "functional-red-black-tree": "^1.0.1", "glob-parent": "^6.0.1", "globals": "^13.15.0", + "globby": "^11.1.0", + "grapheme-splitter": "^1.0.4", "ignore": "^5.2.0", "import-fresh": "^3.0.0", "imurmurhash": "^0.1.4", @@ -10515,9 +10545,9 @@ } }, "eslint-plugin-jsdoc": { - "version": "39.3.2", - "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-39.3.2.tgz", - "integrity": "sha512-RSGN94RYzIJS/WfW3l6cXzRLfJWxvJgNQZ4w0WCaxJWDJMigtwTsILEAfKqmmPkT2rwMH/s3C7G5ChDE6cwPJg==", + "version": "39.3.6", + "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-39.3.6.tgz", + "integrity": "sha512-R6dZ4t83qPdMhIOGr7g2QII2pwCjYyKP+z0tPOfO1bbAbQyKC20Y2Rd6z1te86Lq3T7uM8bNo+VD9YFpE8HU/g==", "dev": true, "requires": { "@es-joy/jsdoccomment": "~0.31.0", @@ -11116,9 +11146,9 @@ } }, "flatted": { - "version": "3.2.6", - "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.6.tgz", - "integrity": "sha512-0sQoMh9s0BYsm+12Huy/rkKxVu4R1+r96YX5cG44rHV0pQ6iC3Q+mkoMFaGWObMFYQxCVT+ssG1ksneA2MI9KQ==", + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz", + "integrity": "sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==", "dev": true }, "flush-write-stream": { @@ -11690,6 +11720,12 @@ "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==", "dev": true }, + "grapheme-splitter": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz", + "integrity": "sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==", + "dev": true + }, "gulp": { "version": "4.0.2", "resolved": "https://registry.npmjs.org/gulp/-/gulp-4.0.2.tgz", diff --git a/package.json b/package.json index 23d2b40b5cfe2..569938200e734 100644 --- a/package.json +++ b/package.json @@ -49,20 +49,20 @@ "@types/node-fetch": "^2.6.2", "@types/source-map-support": "latest", "@types/xml2js": "^0.4.11", - "@typescript-eslint/eslint-plugin": "^5.28.0", - "@typescript-eslint/parser": "^5.28.0", - "@typescript-eslint/utils": "^5.28.0", + "@typescript-eslint/eslint-plugin": "^5.33.1", + "@typescript-eslint/parser": "^5.33.1", + "@typescript-eslint/utils": "^5.33.1", "async": "latest", - "azure-devops-node-api": "^11.1.1", + "azure-devops-node-api": "^11.2.0", "chai": "latest", "chalk": "^4.1.2", - "del": "6.1.1", + "del": "^6.1.1", "diff": "^5.1.0", - "eslint": "8.17.0", - "eslint-formatter-autolinkable-stylish": "1.2.0", - "eslint-plugin-import": "2.26.0", - "eslint-plugin-jsdoc": "39.3.2", - "eslint-plugin-no-null": "1.0.2", + "eslint": "^8.22.0", + "eslint-formatter-autolinkable-stylish": "^1.2.0", + "eslint-plugin-import": "^2.26.0", + "eslint-plugin-jsdoc": "^39.3.6", + "eslint-plugin-no-null": "^1.0.2", "fancy-log": "latest", "fs-extra": "^9.1.0", "glob": "latest", @@ -81,7 +81,7 @@ "node-fetch": "^2.6.7", "prex": "^0.4.7", "source-map-support": "latest", - "typescript": "^4.5.5", + "typescript": "^4.7.4", "vinyl": "latest", "which": "^2.0.2", "xml2js": "^0.4.23" From 50041bdc7d8f18d863a319df34a16b20355c0fc1 Mon Sep 17 00:00:00 2001 From: TypeScript Bot Date: Sat, 20 Aug 2022 06:06:43 +0000 Subject: [PATCH 07/16] Update package-lock.json --- package-lock.json | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/package-lock.json b/package-lock.json index 3f8d272cbb370..ce6538b9bb62d 100644 --- a/package-lock.json +++ b/package-lock.json @@ -340,9 +340,9 @@ } }, "node_modules/@octokit/openapi-types": { - "version": "13.2.0", - "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-13.2.0.tgz", - "integrity": "sha512-1BhjsVrCe2cyE36Rorpeq331bcYzdb9ksCpkFdAN6RVtW67YdO3Pl4YXDC5dF2D1ia76MssJdn5RV+Gj9Fu7dQ==", + "version": "13.3.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-13.3.0.tgz", + "integrity": "sha512-LQGIQDpCUNVm+Egqtj9nZJ383HsuS/LFaSqV5uMjD9eev4x54IUaom3WV3PEdDeu/pEagL7FyrKmvYn+Yrb30A==", "dev": true }, "node_modules/@octokit/plugin-paginate-rest": { @@ -597,9 +597,9 @@ "dev": true }, "node_modules/@types/node": { - "version": "18.7.6", - "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.6.tgz", - "integrity": "sha512-EdxgKRXgYsNITy5mjjXjVE/CS8YENSdhiagGrLqjG0pvA2owgJ6i4l7wy/PFZGC0B1/H20lWKN7ONVDNYDZm7A==", + "version": "18.7.8", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.8.tgz", + "integrity": "sha512-/YP55EMK2341JkODUb8DM9O0x1SIz2aBvyF33Uf1c76St3VpsMXEIW0nxuKkq/5cxnbz0RD9cfwNZHEAZQD3ag==", "dev": true }, "node_modules/@types/node-fetch": { @@ -8794,9 +8794,9 @@ } }, "@octokit/openapi-types": { - "version": "13.2.0", - "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-13.2.0.tgz", - "integrity": "sha512-1BhjsVrCe2cyE36Rorpeq331bcYzdb9ksCpkFdAN6RVtW67YdO3Pl4YXDC5dF2D1ia76MssJdn5RV+Gj9Fu7dQ==", + "version": "13.3.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-13.3.0.tgz", + "integrity": "sha512-LQGIQDpCUNVm+Egqtj9nZJ383HsuS/LFaSqV5uMjD9eev4x54IUaom3WV3PEdDeu/pEagL7FyrKmvYn+Yrb30A==", "dev": true }, "@octokit/plugin-paginate-rest": { @@ -9028,9 +9028,9 @@ "dev": true }, "@types/node": { - "version": "18.7.6", - "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.6.tgz", - "integrity": "sha512-EdxgKRXgYsNITy5mjjXjVE/CS8YENSdhiagGrLqjG0pvA2owgJ6i4l7wy/PFZGC0B1/H20lWKN7ONVDNYDZm7A==", + "version": "18.7.8", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.8.tgz", + "integrity": "sha512-/YP55EMK2341JkODUb8DM9O0x1SIz2aBvyF33Uf1c76St3VpsMXEIW0nxuKkq/5cxnbz0RD9cfwNZHEAZQD3ag==", "dev": true }, "@types/node-fetch": { From 7cab3459d20b34b2f7357b51783703d257b1ce49 Mon Sep 17 00:00:00 2001 From: TypeScript Bot Date: Sun, 21 Aug 2022 06:07:14 +0000 Subject: [PATCH 08/16] Update package-lock.json --- package-lock.json | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/package-lock.json b/package-lock.json index ce6538b9bb62d..8e9c292f4aea9 100644 --- a/package-lock.json +++ b/package-lock.json @@ -340,9 +340,9 @@ } }, "node_modules/@octokit/openapi-types": { - "version": "13.3.0", - "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-13.3.0.tgz", - "integrity": "sha512-LQGIQDpCUNVm+Egqtj9nZJ383HsuS/LFaSqV5uMjD9eev4x54IUaom3WV3PEdDeu/pEagL7FyrKmvYn+Yrb30A==", + "version": "13.4.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-13.4.0.tgz", + "integrity": "sha512-2mVzW0X1+HDO3jF80/+QFZNzJiTefELKbhMu6yaBYbp/1gSMkVDm4rT472gJljTokWUlXaaE63m7WrWENhMDLw==", "dev": true }, "node_modules/@octokit/plugin-paginate-rest": { @@ -432,12 +432,12 @@ } }, "node_modules/@octokit/types": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/@octokit/types/-/types-7.1.0.tgz", - "integrity": "sha512-+ClA0jRc9zGFj5mfQeQNfgTlelzhpAexbAueQG1t2Xn8yhgnsjkF8bgLcUUpwrpqkv296uXyiGwkqXRSU7KYzQ==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-7.1.1.tgz", + "integrity": "sha512-Dx6cNTORyVaKY0Yeb9MbHksk79L8GXsihbG6PtWqTpkyA2TY1qBWE26EQXVG3dHwY9Femdd/WEeRUEiD0+H3TQ==", "dev": true, "dependencies": { - "@octokit/openapi-types": "^13.1.0" + "@octokit/openapi-types": "^13.4.0" } }, "node_modules/@types/async": { @@ -8794,9 +8794,9 @@ } }, "@octokit/openapi-types": { - "version": "13.3.0", - "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-13.3.0.tgz", - "integrity": "sha512-LQGIQDpCUNVm+Egqtj9nZJ383HsuS/LFaSqV5uMjD9eev4x54IUaom3WV3PEdDeu/pEagL7FyrKmvYn+Yrb30A==", + "version": "13.4.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-13.4.0.tgz", + "integrity": "sha512-2mVzW0X1+HDO3jF80/+QFZNzJiTefELKbhMu6yaBYbp/1gSMkVDm4rT472gJljTokWUlXaaE63m7WrWENhMDLw==", "dev": true }, "@octokit/plugin-paginate-rest": { @@ -8863,12 +8863,12 @@ } }, "@octokit/types": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/@octokit/types/-/types-7.1.0.tgz", - "integrity": "sha512-+ClA0jRc9zGFj5mfQeQNfgTlelzhpAexbAueQG1t2Xn8yhgnsjkF8bgLcUUpwrpqkv296uXyiGwkqXRSU7KYzQ==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-7.1.1.tgz", + "integrity": "sha512-Dx6cNTORyVaKY0Yeb9MbHksk79L8GXsihbG6PtWqTpkyA2TY1qBWE26EQXVG3dHwY9Femdd/WEeRUEiD0+H3TQ==", "dev": true, "requires": { - "@octokit/openapi-types": "^13.1.0" + "@octokit/openapi-types": "^13.4.0" } }, "@types/async": { From 38e91fb12099b526e9a2cb5ad6aacfc89d5060ca Mon Sep 17 00:00:00 2001 From: Alex Hsu Date: Sun, 21 Aug 2022 03:07:27 -0700 Subject: [PATCH 09/16] LEGO: Merge pull request 50389 LEGO: Merge pull request 50389 --- .../diagnosticMessages.generated.json.lcl | 78 +++++++++---------- 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl index 2f7628b06453b..f797ba6e925de 100644 --- a/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -1102,7 +1102,7 @@ - + @@ -1156,7 +1156,7 @@ - + @@ -1489,7 +1489,7 @@ - + @@ -1516,7 +1516,7 @@ - + @@ -1525,7 +1525,7 @@ - + @@ -1579,7 +1579,7 @@ - + @@ -1588,7 +1588,7 @@ - + @@ -1954,7 +1954,7 @@ - + @@ -2425,7 +2425,7 @@ - + @@ -2443,7 +2443,7 @@ - + @@ -2488,7 +2488,7 @@ - + @@ -2755,7 +2755,7 @@ - + @@ -2782,7 +2782,7 @@ - + @@ -2791,7 +2791,7 @@ - + @@ -2863,7 +2863,7 @@ - + @@ -3070,7 +3070,7 @@ - + @@ -3079,7 +3079,7 @@ - + @@ -3406,7 +3406,7 @@ - + @@ -3415,7 +3415,7 @@ - + @@ -4066,7 +4066,7 @@ - + @@ -4228,7 +4228,7 @@ - + @@ -6787,7 +6787,7 @@ - + @@ -9103,7 +9103,7 @@ - + @@ -9112,7 +9112,7 @@ - + @@ -9121,7 +9121,7 @@ - + @@ -10690,7 +10690,7 @@ - + @@ -12535,7 +12535,7 @@ - + @@ -12544,7 +12544,7 @@ - + @@ -12637,7 +12637,7 @@ - + @@ -15109,7 +15109,7 @@ - + @@ -15118,7 +15118,7 @@ - + @@ -15127,7 +15127,7 @@ - + @@ -15472,7 +15472,7 @@ - + @@ -15508,7 +15508,7 @@ - + @@ -16390,7 +16390,7 @@ - + @@ -16825,7 +16825,7 @@ - + @@ -16834,7 +16834,7 @@ - + @@ -16909,7 +16909,7 @@ - + @@ -16936,7 +16936,7 @@ - + From 76357ba802ae92c4a4f1c2f72cd833e5ed3ab05d Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Sun, 21 Aug 2022 17:48:45 -0700 Subject: [PATCH 10/16] Swap `forEachChild` to use a table of functions instead of a `switch` statement. (#50225) * Swap `forEachChild` to use an array of functions instead of a `switch` statement. * Let's see if 'new' changes anything. * Co-locate each assignment into `forEachChildTable`. * Try `push`ing undefined to create a packed Array. * Try using an unconditional no-op function. * `forEach` -> `forEachChildIn` * Remove the optional chain if we are pre-filling with no-ops. * Grab function directly to avoid possible `.call` overhead from downlevel emit. * Swap to object literal. * Lints and formatting. --- src/compiler/parser.ts | 1288 +++++++++++++++++++++++----------------- 1 file changed, 732 insertions(+), 556 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index b6913a31b0d18..1b82ae4d9a335 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -95,6 +95,734 @@ namespace ts { return isMetaProperty(node) && node.keywordToken === SyntaxKind.ImportKeyword && node.name.escapedText === "meta"; } + type ForEachChildFunction = (node: TNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) => T | undefined; + const forEachChildTable = { + [SyntaxKind.QualifiedName]: function forEachChildInQualifiedName(node: QualifiedName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.right); + }, + [SyntaxKind.TypeParameter]: function forEachChildInTypeParameter(node: TypeParameterDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.constraint) || + visitNode(cbNode, node.default) || + visitNode(cbNode, node.expression); + }, + [SyntaxKind.ShorthandPropertyAssignment]: function forEachChildInShorthandPropertyAssignment(node: ShorthandPropertyAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.equalsToken) || + visitNode(cbNode, node.objectAssignmentInitializer); + }, + [SyntaxKind.SpreadAssignment]: function forEachChildInSpreadAssignment(node: SpreadAssignment, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.Parameter]: function forEachChildInParameter(node: ParameterDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + }, + [SyntaxKind.PropertyDeclaration]: function forEachChildInPropertyDeclaration(node: PropertyDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + }, + [SyntaxKind.PropertySignature]: function forEachChildInPropertySignature(node: PropertySignature, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + }, + [SyntaxKind.PropertyAssignment]: function forEachChildInPropertyAssignment(node: PropertyAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.initializer); + }, + [SyntaxKind.VariableDeclaration]: function forEachChildInVariableDeclaration(node: VariableDeclaration, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + }, + [SyntaxKind.BindingElement]: function forEachChildInBindingElement(node: BindingElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + }, + [SyntaxKind.IndexSignature]: function forEachChildInIndexSignature(node: IndexSignatureDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + }, + [SyntaxKind.ConstructorType]: function forEachChildInConstructorType(node: ConstructorTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + }, + [SyntaxKind.FunctionType]: function forEachChildInFunctionType(node: FunctionTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + }, + [SyntaxKind.CallSignature]: forEachChildInCallOrConstructSignature, + [SyntaxKind.ConstructSignature]: forEachChildInCallOrConstructSignature, + [SyntaxKind.MethodDeclaration]: function forEachChildInMethodDeclaration(node: MethodDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + }, + [SyntaxKind.MethodSignature]: function forEachChildInMethodSignature(node: MethodSignature, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + }, + [SyntaxKind.Constructor]: function forEachChildInConstructor(node: ConstructorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + }, + [SyntaxKind.GetAccessor]: function forEachChildInGetAccessor(node: GetAccessorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + }, + [SyntaxKind.SetAccessor]: function forEachChildInSetAccessor(node: SetAccessorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + }, + [SyntaxKind.FunctionDeclaration]: function forEachChildInFunctionDeclaration(node: FunctionDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + }, + [SyntaxKind.FunctionExpression]: function forEachChildInFunctionExpression(node: FunctionExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + }, + [SyntaxKind.ArrowFunction]: function forEachChildInArrowFunction(node: ArrowFunction, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.equalsGreaterThanToken) || + visitNode(cbNode, node.body); + }, + [SyntaxKind.ClassStaticBlockDeclaration]: function forEachChildInClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.body); + }, + [SyntaxKind.TypeReference]: function forEachChildInTypeReference(node: TypeReferenceNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.typeName) || + visitNodes(cbNode, cbNodes, node.typeArguments); + }, + [SyntaxKind.TypePredicate]: function forEachChildInTypePredicate(node: TypePredicateNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.assertsModifier) || + visitNode(cbNode, node.parameterName) || + visitNode(cbNode, node.type); + }, + [SyntaxKind.TypeQuery]: function forEachChildInTypeQuery(node: TypeQueryNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.exprName) || + visitNodes(cbNode, cbNodes, node.typeArguments); + }, + [SyntaxKind.TypeLiteral]: function forEachChildInTypeLiteral(node: TypeLiteralNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.members); + }, + [SyntaxKind.ArrayType]: function forEachChildInArrayType(node: ArrayTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.elementType); + }, + [SyntaxKind.TupleType]: function forEachChildInTupleType(node: TupleTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.elements); + }, + [SyntaxKind.UnionType]: forEachChildInUnionOrIntersectionType, + [SyntaxKind.IntersectionType]: forEachChildInUnionOrIntersectionType, + [SyntaxKind.ConditionalType]: function forEachChildInConditionalType(node: ConditionalTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.checkType) || + visitNode(cbNode, node.extendsType) || + visitNode(cbNode, node.trueType) || + visitNode(cbNode, node.falseType); + }, + [SyntaxKind.InferType]: function forEachChildInInferType(node: InferTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.typeParameter); + }, + [SyntaxKind.ImportType]: function forEachChildInImportType(node: ImportTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.argument) || + visitNode(cbNode, node.assertions) || + visitNode(cbNode, node.qualifier) || + visitNodes(cbNode, cbNodes, node.typeArguments); + }, + [SyntaxKind.ImportTypeAssertionContainer]: function forEachChildInImportTypeAssertionContainer(node: ImportTypeAssertionContainer, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.assertClause); + }, + [SyntaxKind.ParenthesizedType]: forEachChildInParenthesizedTypeOrTypeOperator, + [SyntaxKind.TypeOperator]: forEachChildInParenthesizedTypeOrTypeOperator, + [SyntaxKind.IndexedAccessType]: function forEachChildInIndexedAccessType(node: IndexedAccessTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.objectType) || + visitNode(cbNode, node.indexType); + }, + [SyntaxKind.MappedType]: function forEachChildInMappedType(node: MappedTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.readonlyToken) || + visitNode(cbNode, node.typeParameter) || + visitNode(cbNode, node.nameType) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type) || + visitNodes(cbNode, cbNodes, node.members); + }, + [SyntaxKind.LiteralType]: function forEachChildInLiteralType(node: LiteralTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.literal); + }, + [SyntaxKind.NamedTupleMember]: function forEachChildInNamedTupleMember(node: NamedTupleMember, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type); + }, + [SyntaxKind.ObjectBindingPattern]: forEachChildInObjectOrArrayBindingPattern, + [SyntaxKind.ArrayBindingPattern]: forEachChildInObjectOrArrayBindingPattern, + [SyntaxKind.ArrayLiteralExpression]: function forEachChildInArrayLiteralExpression(node: ArrayLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.elements); + }, + [SyntaxKind.ObjectLiteralExpression]: function forEachChildInObjectLiteralExpression(node: ObjectLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.properties); + }, + [SyntaxKind.PropertyAccessExpression]: function forEachChildInPropertyAccessExpression(node: PropertyAccessExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.questionDotToken) || + visitNode(cbNode, node.name); + }, + [SyntaxKind.ElementAccessExpression]: function forEachChildInElementAccessExpression(node: ElementAccessExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.questionDotToken) || + visitNode(cbNode, node.argumentExpression); + }, + [SyntaxKind.CallExpression]: forEachChildInCallOrNewExpression, + [SyntaxKind.NewExpression]: forEachChildInCallOrNewExpression, + [SyntaxKind.TaggedTemplateExpression]: function forEachChildInTaggedTemplateExpression(node: TaggedTemplateExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tag) || + visitNode(cbNode, node.questionDotToken) || + visitNodes(cbNode, cbNodes, node.typeArguments) || + visitNode(cbNode, node.template); + }, + [SyntaxKind.TypeAssertionExpression]: function forEachChildInTypeAssertionExpression(node: TypeAssertion, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.type) || + visitNode(cbNode, node.expression); + }, + [SyntaxKind.ParenthesizedExpression]: function forEachChildInParenthesizedExpression(node: ParenthesizedExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.DeleteExpression]: function forEachChildInDeleteExpression(node: DeleteExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.TypeOfExpression]: function forEachChildInTypeOfExpression(node: TypeOfExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.VoidExpression]: function forEachChildInVoidExpression(node: VoidExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.PrefixUnaryExpression]: function forEachChildInPrefixUnaryExpression(node: PrefixUnaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.operand); + }, + [SyntaxKind.YieldExpression]: function forEachChildInYieldExpression(node: YieldExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.expression); + }, + [SyntaxKind.AwaitExpression]: function forEachChildInAwaitExpression(node: AwaitExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.PostfixUnaryExpression]: function forEachChildInPostfixUnaryExpression(node: PostfixUnaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.operand); + }, + [SyntaxKind.BinaryExpression]: function forEachChildInBinaryExpression(node: BinaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.operatorToken) || + visitNode(cbNode, node.right); + }, + [SyntaxKind.AsExpression]: function forEachChildInAsExpression(node: AsExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.type); + }, + [SyntaxKind.NonNullExpression]: function forEachChildInNonNullExpression(node: NonNullExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.MetaProperty]: function forEachChildInMetaProperty(node: MetaProperty, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.name); + }, + [SyntaxKind.ConditionalExpression]: function forEachChildInConditionalExpression(node: ConditionalExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.condition) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.whenTrue) || + visitNode(cbNode, node.colonToken) || + visitNode(cbNode, node.whenFalse); + }, + [SyntaxKind.SpreadElement]: function forEachChildInSpreadElement(node: SpreadElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.Block]: forEachChildInBlock, + [SyntaxKind.ModuleBlock]: forEachChildInBlock, + [SyntaxKind.SourceFile]: function forEachChildInSourceFile(node: SourceFile, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.statements) || + visitNode(cbNode, node.endOfFileToken); + }, + [SyntaxKind.VariableStatement]: function forEachChildInVariableStatement(node: VariableStatement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.declarationList); + }, + [SyntaxKind.VariableDeclarationList]: function forEachChildInVariableDeclarationList(node: VariableDeclarationList, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.declarations); + }, + [SyntaxKind.ExpressionStatement]: function forEachChildInExpressionStatement(node: ExpressionStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.IfStatement]: function forEachChildInIfStatement(node: IfStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.thenStatement) || + visitNode(cbNode, node.elseStatement); + }, + [SyntaxKind.DoStatement]: function forEachChildInDoStatement(node: DoStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.statement) || + visitNode(cbNode, node.expression); + }, + [SyntaxKind.WhileStatement]: function forEachChildInWhileStatement(node: WhileStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + }, + [SyntaxKind.ForStatement]: function forEachChildInForStatement(node: ForStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.condition) || + visitNode(cbNode, node.incrementor) || + visitNode(cbNode, node.statement); + }, + [SyntaxKind.ForInStatement]: function forEachChildInForInStatement(node: ForInStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + }, + [SyntaxKind.ForOfStatement]: function forEachChildInForOfStatement(node: ForOfStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.awaitModifier) || + visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + }, + [SyntaxKind.ContinueStatement]: forEachChildInContinueOrBreakStatement, + [SyntaxKind.BreakStatement]: forEachChildInContinueOrBreakStatement, + [SyntaxKind.ReturnStatement]: function forEachChildInReturnStatement(node: ReturnStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.WithStatement]: function forEachChildInWithStatement(node: WithStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + }, + [SyntaxKind.SwitchStatement]: function forEachChildInSwitchStatement(node: SwitchStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.caseBlock); + }, + [SyntaxKind.CaseBlock]: function forEachChildInCaseBlock(node: CaseBlock, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.clauses); + }, + [SyntaxKind.CaseClause]: function forEachChildInCaseClause(node: CaseClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression) || + visitNodes(cbNode, cbNodes, node.statements); + }, + [SyntaxKind.DefaultClause]: function forEachChildInDefaultClause(node: DefaultClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.statements); + }, + [SyntaxKind.LabeledStatement]: function forEachChildInLabeledStatement(node: LabeledStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.label) || + visitNode(cbNode, node.statement); + }, + [SyntaxKind.ThrowStatement]: function forEachChildInThrowStatement(node: ThrowStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.TryStatement]: function forEachChildInTryStatement(node: TryStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tryBlock) || + visitNode(cbNode, node.catchClause) || + visitNode(cbNode, node.finallyBlock); + }, + [SyntaxKind.CatchClause]: function forEachChildInCatchClause(node: CatchClause, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.variableDeclaration) || + visitNode(cbNode, node.block); + }, + [SyntaxKind.Decorator]: function forEachChildInDecorator(node: Decorator, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.ClassDeclaration]: forEachChildInClassDeclarationOrExpression, + [SyntaxKind.ClassExpression]: forEachChildInClassDeclarationOrExpression, + [SyntaxKind.InterfaceDeclaration]: function forEachChildInInterfaceDeclaration(node: InterfaceDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.heritageClauses) || + visitNodes(cbNode, cbNodes, node.members); + }, + [SyntaxKind.TypeAliasDeclaration]: function forEachChildInTypeAliasDeclaration(node: TypeAliasDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNode(cbNode, node.type); + }, + [SyntaxKind.EnumDeclaration]: function forEachChildInEnumDeclaration(node: EnumDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.members); + }, + [SyntaxKind.EnumMember]: function forEachChildInEnumMember(node: EnumMember, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + }, + [SyntaxKind.ModuleDeclaration]: function forEachChildInModuleDeclaration(node: ModuleDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.body); + }, + [SyntaxKind.ImportEqualsDeclaration]: function forEachChildInImportEqualsDeclaration(node: ImportEqualsDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.moduleReference); + }, + [SyntaxKind.ImportDeclaration]: function forEachChildInImportDeclaration(node: ImportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.importClause) || + visitNode(cbNode, node.moduleSpecifier) || + visitNode(cbNode, node.assertClause); + }, + [SyntaxKind.ImportClause]: function forEachChildInImportClause(node: ImportClause, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.namedBindings); + }, + [SyntaxKind.AssertClause]: function forEachChildInAssertClause(node: AssertClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.elements); + }, + [SyntaxKind.AssertEntry]: function forEachChildInAssertEntry(node: AssertEntry, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.value); + }, + [SyntaxKind.NamespaceExportDeclaration]: function forEachChildInNamespaceExportDeclaration(node: NamespaceExportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNode(cbNode, node.name); + }, + [SyntaxKind.NamespaceImport]: function forEachChildInNamespaceImport(node: NamespaceImport, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.name); + }, + [SyntaxKind.NamespaceExport]: function forEachChildInNamespaceExport(node: NamespaceExport, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.name); + }, + [SyntaxKind.NamedImports]: forEachChildInNamedImportsOrExports, + [SyntaxKind.NamedExports]: forEachChildInNamedImportsOrExports, + [SyntaxKind.ExportDeclaration]: function forEachChildInExportDeclaration(node: ExportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.exportClause) || + visitNode(cbNode, node.moduleSpecifier) || + visitNode(cbNode, node.assertClause); + }, + [SyntaxKind.ImportSpecifier]: forEachChildInImportOrExportSpecifier, + [SyntaxKind.ExportSpecifier]: forEachChildInImportOrExportSpecifier, + [SyntaxKind.ExportAssignment]: function forEachChildInExportAssignment(node: ExportAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.expression); + }, + [SyntaxKind.TemplateExpression]: function forEachChildInTemplateExpression(node: TemplateExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.head) || + visitNodes(cbNode, cbNodes, node.templateSpans); + }, + [SyntaxKind.TemplateSpan]: function forEachChildInTemplateSpan(node: TemplateSpan, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.literal); + }, + [SyntaxKind.TemplateLiteralType]: function forEachChildInTemplateLiteralType(node: TemplateLiteralTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.head) || + visitNodes(cbNode, cbNodes, node.templateSpans); + }, + [SyntaxKind.TemplateLiteralTypeSpan]: function forEachChildInTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.type) || + visitNode(cbNode, node.literal); + }, + [SyntaxKind.ComputedPropertyName]: function forEachChildInComputedPropertyName(node: ComputedPropertyName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.HeritageClause]: function forEachChildInHeritageClause(node: HeritageClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.types); + }, + [SyntaxKind.ExpressionWithTypeArguments]: function forEachChildInExpressionWithTypeArguments(node: ExpressionWithTypeArguments, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression) || + visitNodes(cbNode, cbNodes, node.typeArguments); + }, + [SyntaxKind.ExternalModuleReference]: function forEachChildInExternalModuleReference(node: ExternalModuleReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.MissingDeclaration]: function forEachChildInMissingDeclaration(node: MissingDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers); + }, + [SyntaxKind.CommaListExpression]: function forEachChildInCommaListExpression(node: CommaListExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.elements); + }, + [SyntaxKind.JsxElement]: function forEachChildInJsxElement(node: JsxElement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.openingElement) || + visitNodes(cbNode, cbNodes, node.children) || + visitNode(cbNode, node.closingElement); + }, + [SyntaxKind.JsxFragment]: function forEachChildInJsxFragment(node: JsxFragment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.openingFragment) || + visitNodes(cbNode, cbNodes, node.children) || + visitNode(cbNode, node.closingFragment); + }, + [SyntaxKind.JsxSelfClosingElement]: forEachChildInJsxOpeningOrSelfClosingElement, + [SyntaxKind.JsxOpeningElement]: forEachChildInJsxOpeningOrSelfClosingElement, + [SyntaxKind.JsxAttributes]: function forEachChildInJsxAttributes(node: JsxAttributes, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.properties); + }, + [SyntaxKind.JsxAttribute]: function forEachChildInJsxAttribute(node: JsxAttribute, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + }, + [SyntaxKind.JsxSpreadAttribute]: function forEachChildInJsxSpreadAttribute(node: JsxSpreadAttribute, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + }, + [SyntaxKind.JsxExpression]: function forEachChildInJsxExpression(node: JsxExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.expression); + }, + [SyntaxKind.JsxClosingElement]: function forEachChildInJsxClosingElement(node: JsxClosingElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tagName); + }, + [SyntaxKind.OptionalType]: forEachChildInOptionalRestOrJSDocParameterModifier, + [SyntaxKind.RestType]: forEachChildInOptionalRestOrJSDocParameterModifier, + [SyntaxKind.JSDocTypeExpression]: forEachChildInOptionalRestOrJSDocParameterModifier, + [SyntaxKind.JSDocNonNullableType]: forEachChildInOptionalRestOrJSDocParameterModifier, + [SyntaxKind.JSDocNullableType]: forEachChildInOptionalRestOrJSDocParameterModifier, + [SyntaxKind.JSDocOptionalType]: forEachChildInOptionalRestOrJSDocParameterModifier, + [SyntaxKind.JSDocVariadicType]: forEachChildInOptionalRestOrJSDocParameterModifier, + [SyntaxKind.JSDocFunctionType]: function forEachChildInJSDocFunctionType(node: JSDocFunctionType, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + }, + [SyntaxKind.JSDoc]: function forEachChildInJSDoc(node: JSDoc, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)) + || visitNodes(cbNode, cbNodes, node.tags); + }, + [SyntaxKind.JSDocSeeTag]: function forEachChildInJSDocSeeTag(node: JSDocSeeTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.name) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + }, + [SyntaxKind.JSDocNameReference]: function forEachChildInJSDocNameReference(node: JSDocNameReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.name); + }, + [SyntaxKind.JSDocMemberName]: function forEachChildInJSDocMemberName(node: JSDocMemberName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.right); + }, + [SyntaxKind.JSDocParameterTag]: forEachChildInJSDocParameterOrPropertyTag, + [SyntaxKind.JSDocPropertyTag]: forEachChildInJSDocParameterOrPropertyTag, + [SyntaxKind.JSDocAuthorTag]: function forEachChildInJSDocAuthorTag(node: JSDocAuthorTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tagName) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + }, + [SyntaxKind.JSDocImplementsTag]: function forEachChildInJSDocImplementsTag(node: JSDocImplementsTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.class) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + }, + [SyntaxKind.JSDocAugmentsTag]: function forEachChildInJSDocAugmentsTag(node: JSDocAugmentsTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.class) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + }, + [SyntaxKind.JSDocTemplateTag]: function forEachChildInJSDocTemplateTag(node: JSDocTemplateTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.constraint) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + }, + [SyntaxKind.JSDocTypedefTag]: function forEachChildInJSDocTypedefTag(node: JSDocTypedefTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tagName) || + (node.typeExpression && + node.typeExpression.kind === SyntaxKind.JSDocTypeExpression + ? visitNode(cbNode, node.typeExpression) || + visitNode(cbNode, node.fullName) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)) + : visitNode(cbNode, node.fullName) || + visitNode(cbNode, node.typeExpression) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment))); + }, + [SyntaxKind.JSDocCallbackTag]: function forEachChildInJSDocCallbackTag(node: JSDocCallbackTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.fullName) || + visitNode(cbNode, node.typeExpression) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + }, + [SyntaxKind.JSDocReturnTag]: forEachChildInJSDocReturnTag, + [SyntaxKind.JSDocTypeTag]: forEachChildInJSDocReturnTag, + [SyntaxKind.JSDocThisTag]: forEachChildInJSDocReturnTag, + [SyntaxKind.JSDocEnumTag]: forEachChildInJSDocReturnTag, + [SyntaxKind.JSDocSignature]: function forEachChildInJSDocSignature(node: JSDocSignature, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return forEach(node.typeParameters, cbNode) || + forEach(node.parameters, cbNode) || + visitNode(cbNode, node.type); + }, + [SyntaxKind.JSDocLink]: forEachChildInJSDocLinkCodeOrPlain, + [SyntaxKind.JSDocLinkCode]: forEachChildInJSDocLinkCodeOrPlain, + [SyntaxKind.JSDocLinkPlain]: forEachChildInJSDocLinkCodeOrPlain, + [SyntaxKind.JSDocTypeLiteral]: function forEachChildInJSDocTypeLiteral(node: JSDocTypeLiteral, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return forEach(node.jsDocPropertyTags, cbNode); + }, + [SyntaxKind.JSDocTag]: forEachChildInJSDocTag, + [SyntaxKind.JSDocClassTag]: forEachChildInJSDocTag, + [SyntaxKind.JSDocPublicTag]: forEachChildInJSDocTag, + [SyntaxKind.JSDocPrivateTag]: forEachChildInJSDocTag, + [SyntaxKind.JSDocProtectedTag]: forEachChildInJSDocTag, + [SyntaxKind.JSDocReadonlyTag]: forEachChildInJSDocTag, + [SyntaxKind.JSDocDeprecatedTag]: forEachChildInJSDocTag, + [SyntaxKind.PartiallyEmittedExpression]: forEachChildInPartiallyEmittedExpression, + }; + + // shared + + function forEachChildInCallOrConstructSignature(node: CallSignatureDeclaration | ConstructSignatureDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + }; + + function forEachChildInUnionOrIntersectionType(node: UnionTypeNode | IntersectionTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.types); + } + + function forEachChildInParenthesizedTypeOrTypeOperator(node: ParenthesizedTypeNode | TypeOperatorNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.type); + } + + function forEachChildInObjectOrArrayBindingPattern(node: BindingPattern, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.elements); + } + + function forEachChildInCallOrNewExpression(node: CallExpression | NewExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression) || + // TODO: should we separate these branches out? + visitNode(cbNode, (node as CallExpression).questionDotToken) || + visitNodes(cbNode, cbNodes, node.typeArguments) || + visitNodes(cbNode, cbNodes, node.arguments); + } + + function forEachChildInBlock(node: Block | ModuleBlock, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.statements); + } + + function forEachChildInContinueOrBreakStatement(node: ContinueStatement | BreakStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.label); + } + + function forEachChildInClassDeclarationOrExpression(node: ClassDeclaration | ClassExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.heritageClauses) || + visitNodes(cbNode, cbNodes, node.members); + } + + function forEachChildInNamedImportsOrExports(node: NamedImports | NamedExports, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNodes(cbNode, cbNodes, node.elements); + } + + function forEachChildInImportOrExportSpecifier(node: ImportSpecifier | ExportSpecifier, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.name); + } + + function forEachChildInJsxOpeningOrSelfClosingElement(node: JsxOpeningLikeElement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tagName) || + visitNodes(cbNode, cbNodes, node.typeArguments) || + visitNode(cbNode, node.attributes); + } + + function forEachChildInOptionalRestOrJSDocParameterModifier(node: OptionalTypeNode | RestTypeNode | JSDocTypeExpression | JSDocNullableType | JSDocNonNullableType | JSDocOptionalType | JSDocVariadicType, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.type); + } + + function forEachChildInJSDocParameterOrPropertyTag(node: JSDocParameterTag | JSDocPropertyTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tagName) || + (node.isNameFirst + ? visitNode(cbNode, node.name) || visitNode(cbNode, node.typeExpression) + : visitNode(cbNode, node.typeExpression) || visitNode(cbNode, node.name)) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + + function forEachChildInJSDocReturnTag(node: JSDocReturnTag | JSDocTypeTag | JSDocThisTag | JSDocEnumTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.typeExpression) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + + function forEachChildInJSDocLinkCodeOrPlain(node: JSDocLink | JSDocLinkCode | JSDocLinkPlain, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.name); + } + + function forEachChildInJSDocTag(node: JSDocUnknownTag | JSDocClassTag | JSDocPublicTag | JSDocPrivateTag | JSDocProtectedTag | JSDocReadonlyTag | JSDocDeprecatedTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.tagName) + || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + + function forEachChildInPartiallyEmittedExpression(node: PartiallyEmittedExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { + return visitNode(cbNode, node.expression); + } + /** * Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes * stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise, @@ -109,564 +837,12 @@ namespace ts { * that they appear in the source code. The language service depends on this property to locate nodes by position. */ export function forEachChild(node: Node, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { - if (!node || node.kind <= SyntaxKind.LastToken) { + if (node === undefined || node.kind <= SyntaxKind.LastToken) { return; } - switch (node.kind) { - case SyntaxKind.QualifiedName: - return visitNode(cbNode, (node as QualifiedName).left) || - visitNode(cbNode, (node as QualifiedName).right); - case SyntaxKind.TypeParameter: - return visitNodes(cbNode, cbNodes, (node as TypeParameterDeclaration).modifiers) || - visitNode(cbNode, (node as TypeParameterDeclaration).name) || - visitNode(cbNode, (node as TypeParameterDeclaration).constraint) || - visitNode(cbNode, (node as TypeParameterDeclaration).default) || - visitNode(cbNode, (node as TypeParameterDeclaration).expression); - case SyntaxKind.ShorthandPropertyAssignment: - return visitNodes(cbNode, cbNodes, (node as ShorthandPropertyAssignment).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as ShorthandPropertyAssignment).modifiers) || - visitNode(cbNode, (node as ShorthandPropertyAssignment).name) || - visitNode(cbNode, (node as ShorthandPropertyAssignment).questionToken) || - visitNode(cbNode, (node as ShorthandPropertyAssignment).exclamationToken) || - visitNode(cbNode, (node as ShorthandPropertyAssignment).equalsToken) || - visitNode(cbNode, (node as ShorthandPropertyAssignment).objectAssignmentInitializer); - case SyntaxKind.SpreadAssignment: - return visitNode(cbNode, (node as SpreadAssignment).expression); - case SyntaxKind.Parameter: - return visitNodes(cbNode, cbNodes, (node as ParameterDeclaration).modifiers) || - visitNode(cbNode, (node as ParameterDeclaration).dotDotDotToken) || - visitNode(cbNode, (node as ParameterDeclaration).name) || - visitNode(cbNode, (node as ParameterDeclaration).questionToken) || - visitNode(cbNode, (node as ParameterDeclaration).type) || - visitNode(cbNode, (node as ParameterDeclaration).initializer); - case SyntaxKind.PropertyDeclaration: - return visitNodes(cbNode, cbNodes, (node as PropertyDeclaration).modifiers) || - visitNode(cbNode, (node as PropertyDeclaration).name) || - visitNode(cbNode, (node as PropertyDeclaration).questionToken) || - visitNode(cbNode, (node as PropertyDeclaration).exclamationToken) || - visitNode(cbNode, (node as PropertyDeclaration).type) || - visitNode(cbNode, (node as PropertyDeclaration).initializer); - case SyntaxKind.PropertySignature: - return visitNodes(cbNode, cbNodes, (node as PropertySignature).modifiers) || - visitNode(cbNode, (node as PropertySignature).name) || - visitNode(cbNode, (node as PropertySignature).questionToken) || - visitNode(cbNode, (node as PropertySignature).type) || - visitNode(cbNode, (node as PropertySignature).initializer); - case SyntaxKind.PropertyAssignment: - return visitNodes(cbNode, cbNodes, (node as PropertyAssignment).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as PropertyAssignment).modifiers) || - visitNode(cbNode, (node as PropertyAssignment).name) || - visitNode(cbNode, (node as PropertyAssignment).questionToken) || - visitNode(cbNode, (node as PropertyAssignment).exclamationToken) || - visitNode(cbNode, (node as PropertyAssignment).initializer); - case SyntaxKind.VariableDeclaration: - return visitNode(cbNode, (node as VariableDeclaration).name) || - visitNode(cbNode, (node as VariableDeclaration).exclamationToken) || - visitNode(cbNode, (node as VariableDeclaration).type) || - visitNode(cbNode, (node as VariableDeclaration).initializer); - case SyntaxKind.BindingElement: - return visitNode(cbNode, (node as BindingElement).dotDotDotToken) || - visitNode(cbNode, (node as BindingElement).propertyName) || - visitNode(cbNode, (node as BindingElement).name) || - visitNode(cbNode, (node as BindingElement).initializer); - case SyntaxKind.IndexSignature: - return visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).modifiers) || - visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).parameters) || - visitNode(cbNode, (node as IndexSignatureDeclaration).type); - case SyntaxKind.ConstructorType: - return visitNodes(cbNode, cbNodes, (node as ConstructorTypeNode).modifiers) || - visitNodes(cbNode, cbNodes, (node as ConstructorTypeNode).typeParameters) || - visitNodes(cbNode, cbNodes, (node as ConstructorTypeNode).parameters) || - visitNode(cbNode, (node as ConstructorTypeNode).type); - case SyntaxKind.FunctionType: - return visitNodes(cbNode, cbNodes, (node as FunctionTypeNode).modifiers) || - visitNodes(cbNode, cbNodes, (node as FunctionTypeNode).typeParameters) || - visitNodes(cbNode, cbNodes, (node as FunctionTypeNode).parameters) || - visitNode(cbNode, (node as FunctionTypeNode).type); - case SyntaxKind.CallSignature: - case SyntaxKind.ConstructSignature: - return visitNodes(cbNode, cbNodes, (node as CallSignatureDeclaration | ConstructSignatureDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as CallSignatureDeclaration | ConstructSignatureDeclaration).parameters) || - visitNode(cbNode, (node as CallSignatureDeclaration | ConstructSignatureDeclaration).type); - case SyntaxKind.MethodDeclaration: - return visitNodes(cbNode, cbNodes, (node as MethodDeclaration).modifiers) || - visitNode(cbNode, (node as MethodDeclaration).asteriskToken) || - visitNode(cbNode, (node as MethodDeclaration).name) || - visitNode(cbNode, (node as MethodDeclaration).questionToken) || - visitNode(cbNode, (node as MethodDeclaration).exclamationToken) || - visitNodes(cbNode, cbNodes, (node as MethodDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as MethodDeclaration).parameters) || - visitNode(cbNode, (node as MethodDeclaration).type) || - visitNode(cbNode, (node as MethodDeclaration).body); - case SyntaxKind.MethodSignature: - return visitNodes(cbNode, cbNodes, (node as MethodSignature).modifiers) || - visitNode(cbNode, (node as MethodSignature).name) || - visitNode(cbNode, (node as MethodSignature).questionToken) || - visitNodes(cbNode, cbNodes, (node as MethodSignature).typeParameters) || - visitNodes(cbNode, cbNodes, (node as MethodSignature).parameters) || - visitNode(cbNode, (node as MethodSignature).type); - case SyntaxKind.Constructor: - return visitNodes(cbNode, cbNodes, (node as ConstructorDeclaration).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as ConstructorDeclaration).modifiers) || - visitNode(cbNode, (node as ConstructorDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as ConstructorDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as ConstructorDeclaration).parameters) || - visitNode(cbNode, (node as ConstructorDeclaration).type) || - visitNode(cbNode, (node as ConstructorDeclaration).body); - case SyntaxKind.GetAccessor: - return visitNodes(cbNode, cbNodes, (node as GetAccessorDeclaration).modifiers) || - visitNode(cbNode, (node as GetAccessorDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as GetAccessorDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as GetAccessorDeclaration).parameters) || - visitNode(cbNode, (node as GetAccessorDeclaration).type) || - visitNode(cbNode, (node as GetAccessorDeclaration).body); - case SyntaxKind.SetAccessor: - return visitNodes(cbNode, cbNodes, (node as SetAccessorDeclaration).modifiers) || - visitNode(cbNode, (node as SetAccessorDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as SetAccessorDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as SetAccessorDeclaration).parameters) || - visitNode(cbNode, (node as SetAccessorDeclaration).type) || - visitNode(cbNode, (node as SetAccessorDeclaration).body); - case SyntaxKind.FunctionDeclaration: - return visitNodes(cbNode, cbNodes, (node as FunctionDeclaration).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as FunctionDeclaration).modifiers) || - visitNode(cbNode, (node as FunctionDeclaration).asteriskToken) || - visitNode(cbNode, (node as FunctionDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as FunctionDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as FunctionDeclaration).parameters) || - visitNode(cbNode, (node as FunctionDeclaration).type) || - visitNode(cbNode, (node as FunctionDeclaration).body); - case SyntaxKind.FunctionExpression: - return visitNodes(cbNode, cbNodes, (node as FunctionExpression).modifiers) || - visitNode(cbNode, (node as FunctionExpression).asteriskToken) || - visitNode(cbNode, (node as FunctionExpression).name) || - visitNodes(cbNode, cbNodes, (node as FunctionExpression).typeParameters) || - visitNodes(cbNode, cbNodes, (node as FunctionExpression).parameters) || - visitNode(cbNode, (node as FunctionExpression).type) || - visitNode(cbNode, (node as FunctionExpression).body); - case SyntaxKind.ArrowFunction: - return visitNodes(cbNode, cbNodes, (node as ArrowFunction).modifiers) || - visitNodes(cbNode, cbNodes, (node as ArrowFunction).typeParameters) || - visitNodes(cbNode, cbNodes, (node as ArrowFunction).parameters) || - visitNode(cbNode, (node as ArrowFunction).type) || - visitNode(cbNode, (node as ArrowFunction).equalsGreaterThanToken) || - visitNode(cbNode, (node as ArrowFunction).body); - case SyntaxKind.ClassStaticBlockDeclaration: - return visitNodes(cbNode, cbNodes, (node as ClassStaticBlockDeclaration).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as ClassStaticBlockDeclaration).modifiers) || - visitNode(cbNode, (node as ClassStaticBlockDeclaration).body); - case SyntaxKind.TypeReference: - return visitNode(cbNode, (node as TypeReferenceNode).typeName) || - visitNodes(cbNode, cbNodes, (node as TypeReferenceNode).typeArguments); - case SyntaxKind.TypePredicate: - return visitNode(cbNode, (node as TypePredicateNode).assertsModifier) || - visitNode(cbNode, (node as TypePredicateNode).parameterName) || - visitNode(cbNode, (node as TypePredicateNode).type); - case SyntaxKind.TypeQuery: - return visitNode(cbNode, (node as TypeQueryNode).exprName) || - visitNodes(cbNode, cbNodes, (node as TypeQueryNode).typeArguments); - case SyntaxKind.TypeLiteral: - return visitNodes(cbNode, cbNodes, (node as TypeLiteralNode).members); - case SyntaxKind.ArrayType: - return visitNode(cbNode, (node as ArrayTypeNode).elementType); - case SyntaxKind.TupleType: - return visitNodes(cbNode, cbNodes, (node as TupleTypeNode).elements); - case SyntaxKind.UnionType: - case SyntaxKind.IntersectionType: - return visitNodes(cbNode, cbNodes, (node as UnionOrIntersectionTypeNode).types); - case SyntaxKind.ConditionalType: - return visitNode(cbNode, (node as ConditionalTypeNode).checkType) || - visitNode(cbNode, (node as ConditionalTypeNode).extendsType) || - visitNode(cbNode, (node as ConditionalTypeNode).trueType) || - visitNode(cbNode, (node as ConditionalTypeNode).falseType); - case SyntaxKind.InferType: - return visitNode(cbNode, (node as InferTypeNode).typeParameter); - case SyntaxKind.ImportType: - return visitNode(cbNode, (node as ImportTypeNode).argument) || - visitNode(cbNode, (node as ImportTypeNode).assertions) || - visitNode(cbNode, (node as ImportTypeNode).qualifier) || - visitNodes(cbNode, cbNodes, (node as ImportTypeNode).typeArguments); - case SyntaxKind.ImportTypeAssertionContainer: - return visitNode(cbNode, (node as ImportTypeAssertionContainer).assertClause); - case SyntaxKind.ParenthesizedType: - case SyntaxKind.TypeOperator: - return visitNode(cbNode, (node as ParenthesizedTypeNode | TypeOperatorNode).type); - case SyntaxKind.IndexedAccessType: - return visitNode(cbNode, (node as IndexedAccessTypeNode).objectType) || - visitNode(cbNode, (node as IndexedAccessTypeNode).indexType); - case SyntaxKind.MappedType: - return visitNode(cbNode, (node as MappedTypeNode).readonlyToken) || - visitNode(cbNode, (node as MappedTypeNode).typeParameter) || - visitNode(cbNode, (node as MappedTypeNode).nameType) || - visitNode(cbNode, (node as MappedTypeNode).questionToken) || - visitNode(cbNode, (node as MappedTypeNode).type) || - visitNodes(cbNode, cbNodes, (node as MappedTypeNode).members); - case SyntaxKind.LiteralType: - return visitNode(cbNode, (node as LiteralTypeNode).literal); - case SyntaxKind.NamedTupleMember: - return visitNode(cbNode, (node as NamedTupleMember).dotDotDotToken) || - visitNode(cbNode, (node as NamedTupleMember).name) || - visitNode(cbNode, (node as NamedTupleMember).questionToken) || - visitNode(cbNode, (node as NamedTupleMember).type); - case SyntaxKind.ObjectBindingPattern: - case SyntaxKind.ArrayBindingPattern: - return visitNodes(cbNode, cbNodes, (node as BindingPattern).elements); - case SyntaxKind.ArrayLiteralExpression: - return visitNodes(cbNode, cbNodes, (node as ArrayLiteralExpression).elements); - case SyntaxKind.ObjectLiteralExpression: - return visitNodes(cbNode, cbNodes, (node as ObjectLiteralExpression).properties); - case SyntaxKind.PropertyAccessExpression: - return visitNode(cbNode, (node as PropertyAccessExpression).expression) || - visitNode(cbNode, (node as PropertyAccessExpression).questionDotToken) || - visitNode(cbNode, (node as PropertyAccessExpression).name); - case SyntaxKind.ElementAccessExpression: - return visitNode(cbNode, (node as ElementAccessExpression).expression) || - visitNode(cbNode, (node as ElementAccessExpression).questionDotToken) || - visitNode(cbNode, (node as ElementAccessExpression).argumentExpression); - case SyntaxKind.CallExpression: - case SyntaxKind.NewExpression: - return visitNode(cbNode, (node as CallExpression).expression) || - visitNode(cbNode, (node as CallExpression).questionDotToken) || - visitNodes(cbNode, cbNodes, (node as CallExpression).typeArguments) || - visitNodes(cbNode, cbNodes, (node as CallExpression).arguments); - case SyntaxKind.TaggedTemplateExpression: - return visitNode(cbNode, (node as TaggedTemplateExpression).tag) || - visitNode(cbNode, (node as TaggedTemplateExpression).questionDotToken) || - visitNodes(cbNode, cbNodes, (node as TaggedTemplateExpression).typeArguments) || - visitNode(cbNode, (node as TaggedTemplateExpression).template); - case SyntaxKind.TypeAssertionExpression: - return visitNode(cbNode, (node as TypeAssertion).type) || - visitNode(cbNode, (node as TypeAssertion).expression); - case SyntaxKind.ParenthesizedExpression: - return visitNode(cbNode, (node as ParenthesizedExpression).expression); - case SyntaxKind.DeleteExpression: - return visitNode(cbNode, (node as DeleteExpression).expression); - case SyntaxKind.TypeOfExpression: - return visitNode(cbNode, (node as TypeOfExpression).expression); - case SyntaxKind.VoidExpression: - return visitNode(cbNode, (node as VoidExpression).expression); - case SyntaxKind.PrefixUnaryExpression: - return visitNode(cbNode, (node as PrefixUnaryExpression).operand); - case SyntaxKind.YieldExpression: - return visitNode(cbNode, (node as YieldExpression).asteriskToken) || - visitNode(cbNode, (node as YieldExpression).expression); - case SyntaxKind.AwaitExpression: - return visitNode(cbNode, (node as AwaitExpression).expression); - case SyntaxKind.PostfixUnaryExpression: - return visitNode(cbNode, (node as PostfixUnaryExpression).operand); - case SyntaxKind.BinaryExpression: - return visitNode(cbNode, (node as BinaryExpression).left) || - visitNode(cbNode, (node as BinaryExpression).operatorToken) || - visitNode(cbNode, (node as BinaryExpression).right); - case SyntaxKind.AsExpression: - return visitNode(cbNode, (node as AsExpression).expression) || - visitNode(cbNode, (node as AsExpression).type); - case SyntaxKind.NonNullExpression: - return visitNode(cbNode, (node as NonNullExpression).expression); - case SyntaxKind.MetaProperty: - return visitNode(cbNode, (node as MetaProperty).name); - case SyntaxKind.ConditionalExpression: - return visitNode(cbNode, (node as ConditionalExpression).condition) || - visitNode(cbNode, (node as ConditionalExpression).questionToken) || - visitNode(cbNode, (node as ConditionalExpression).whenTrue) || - visitNode(cbNode, (node as ConditionalExpression).colonToken) || - visitNode(cbNode, (node as ConditionalExpression).whenFalse); - case SyntaxKind.SpreadElement: - return visitNode(cbNode, (node as SpreadElement).expression); - case SyntaxKind.Block: - case SyntaxKind.ModuleBlock: - return visitNodes(cbNode, cbNodes, (node as Block).statements); - case SyntaxKind.SourceFile: - return visitNodes(cbNode, cbNodes, (node as SourceFile).statements) || - visitNode(cbNode, (node as SourceFile).endOfFileToken); - case SyntaxKind.VariableStatement: - return visitNodes(cbNode, cbNodes, (node as VariableStatement).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as VariableStatement).modifiers) || - visitNode(cbNode, (node as VariableStatement).declarationList); - case SyntaxKind.VariableDeclarationList: - return visitNodes(cbNode, cbNodes, (node as VariableDeclarationList).declarations); - case SyntaxKind.ExpressionStatement: - return visitNode(cbNode, (node as ExpressionStatement).expression); - case SyntaxKind.IfStatement: - return visitNode(cbNode, (node as IfStatement).expression) || - visitNode(cbNode, (node as IfStatement).thenStatement) || - visitNode(cbNode, (node as IfStatement).elseStatement); - case SyntaxKind.DoStatement: - return visitNode(cbNode, (node as DoStatement).statement) || - visitNode(cbNode, (node as DoStatement).expression); - case SyntaxKind.WhileStatement: - return visitNode(cbNode, (node as WhileStatement).expression) || - visitNode(cbNode, (node as WhileStatement).statement); - case SyntaxKind.ForStatement: - return visitNode(cbNode, (node as ForStatement).initializer) || - visitNode(cbNode, (node as ForStatement).condition) || - visitNode(cbNode, (node as ForStatement).incrementor) || - visitNode(cbNode, (node as ForStatement).statement); - case SyntaxKind.ForInStatement: - return visitNode(cbNode, (node as ForInStatement).initializer) || - visitNode(cbNode, (node as ForInStatement).expression) || - visitNode(cbNode, (node as ForInStatement).statement); - case SyntaxKind.ForOfStatement: - return visitNode(cbNode, (node as ForOfStatement).awaitModifier) || - visitNode(cbNode, (node as ForOfStatement).initializer) || - visitNode(cbNode, (node as ForOfStatement).expression) || - visitNode(cbNode, (node as ForOfStatement).statement); - case SyntaxKind.ContinueStatement: - case SyntaxKind.BreakStatement: - return visitNode(cbNode, (node as BreakOrContinueStatement).label); - case SyntaxKind.ReturnStatement: - return visitNode(cbNode, (node as ReturnStatement).expression); - case SyntaxKind.WithStatement: - return visitNode(cbNode, (node as WithStatement).expression) || - visitNode(cbNode, (node as WithStatement).statement); - case SyntaxKind.SwitchStatement: - return visitNode(cbNode, (node as SwitchStatement).expression) || - visitNode(cbNode, (node as SwitchStatement).caseBlock); - case SyntaxKind.CaseBlock: - return visitNodes(cbNode, cbNodes, (node as CaseBlock).clauses); - case SyntaxKind.CaseClause: - return visitNode(cbNode, (node as CaseClause).expression) || - visitNodes(cbNode, cbNodes, (node as CaseClause).statements); - case SyntaxKind.DefaultClause: - return visitNodes(cbNode, cbNodes, (node as DefaultClause).statements); - case SyntaxKind.LabeledStatement: - return visitNode(cbNode, (node as LabeledStatement).label) || - visitNode(cbNode, (node as LabeledStatement).statement); - case SyntaxKind.ThrowStatement: - return visitNode(cbNode, (node as ThrowStatement).expression); - case SyntaxKind.TryStatement: - return visitNode(cbNode, (node as TryStatement).tryBlock) || - visitNode(cbNode, (node as TryStatement).catchClause) || - visitNode(cbNode, (node as TryStatement).finallyBlock); - case SyntaxKind.CatchClause: - return visitNode(cbNode, (node as CatchClause).variableDeclaration) || - visitNode(cbNode, (node as CatchClause).block); - case SyntaxKind.Decorator: - return visitNode(cbNode, (node as Decorator).expression); - case SyntaxKind.ClassDeclaration: - case SyntaxKind.ClassExpression: - return visitNodes(cbNode, cbNodes, (node as ClassLikeDeclaration).modifiers) || - visitNode(cbNode, (node as ClassLikeDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as ClassLikeDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as ClassLikeDeclaration).heritageClauses) || - visitNodes(cbNode, cbNodes, (node as ClassLikeDeclaration).members); - case SyntaxKind.InterfaceDeclaration: - return visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).modifiers) || - visitNode(cbNode, (node as InterfaceDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as ClassDeclaration).heritageClauses) || - visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).members); - case SyntaxKind.TypeAliasDeclaration: - return visitNodes(cbNode, cbNodes, (node as TypeAliasDeclaration).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as TypeAliasDeclaration).modifiers) || - visitNode(cbNode, (node as TypeAliasDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as TypeAliasDeclaration).typeParameters) || - visitNode(cbNode, (node as TypeAliasDeclaration).type); - case SyntaxKind.EnumDeclaration: - return visitNodes(cbNode, cbNodes, (node as EnumDeclaration).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as EnumDeclaration).modifiers) || - visitNode(cbNode, (node as EnumDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as EnumDeclaration).members); - case SyntaxKind.EnumMember: - return visitNode(cbNode, (node as EnumMember).name) || - visitNode(cbNode, (node as EnumMember).initializer); - case SyntaxKind.ModuleDeclaration: - return visitNodes(cbNode, cbNodes, (node as ModuleDeclaration).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as ModuleDeclaration).modifiers) || - visitNode(cbNode, (node as ModuleDeclaration).name) || - visitNode(cbNode, (node as ModuleDeclaration).body); - case SyntaxKind.ImportEqualsDeclaration: - return visitNodes(cbNode, cbNodes, (node as ImportEqualsDeclaration).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as ImportEqualsDeclaration).modifiers) || - visitNode(cbNode, (node as ImportEqualsDeclaration).name) || - visitNode(cbNode, (node as ImportEqualsDeclaration).moduleReference); - case SyntaxKind.ImportDeclaration: - return visitNodes(cbNode, cbNodes, (node as ImportDeclaration).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as ImportDeclaration).modifiers) || - visitNode(cbNode, (node as ImportDeclaration).importClause) || - visitNode(cbNode, (node as ImportDeclaration).moduleSpecifier) || - visitNode(cbNode, (node as ImportDeclaration).assertClause); - case SyntaxKind.ImportClause: - return visitNode(cbNode, (node as ImportClause).name) || - visitNode(cbNode, (node as ImportClause).namedBindings); - case SyntaxKind.AssertClause: - return visitNodes(cbNode, cbNodes, (node as AssertClause).elements); - case SyntaxKind.AssertEntry: - return visitNode(cbNode, (node as AssertEntry).name) || - visitNode(cbNode, (node as AssertEntry).value); - case SyntaxKind.NamespaceExportDeclaration: - return visitNodes(cbNode, cbNodes, (node as NamespaceExportDeclaration).illegalDecorators) || - visitNode(cbNode, (node as NamespaceExportDeclaration).name); - case SyntaxKind.NamespaceImport: - return visitNode(cbNode, (node as NamespaceImport).name); - case SyntaxKind.NamespaceExport: - return visitNode(cbNode, (node as NamespaceExport).name); - case SyntaxKind.NamedImports: - case SyntaxKind.NamedExports: - return visitNodes(cbNode, cbNodes, (node as NamedImportsOrExports).elements); - case SyntaxKind.ExportDeclaration: - return visitNodes(cbNode, cbNodes, (node as ExportDeclaration).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as ExportDeclaration).modifiers) || - visitNode(cbNode, (node as ExportDeclaration).exportClause) || - visitNode(cbNode, (node as ExportDeclaration).moduleSpecifier) || - visitNode(cbNode, (node as ExportDeclaration).assertClause); - case SyntaxKind.ImportSpecifier: - case SyntaxKind.ExportSpecifier: - return visitNode(cbNode, (node as ImportOrExportSpecifier).propertyName) || - visitNode(cbNode, (node as ImportOrExportSpecifier).name); - case SyntaxKind.ExportAssignment: - return visitNodes(cbNode, cbNodes, (node as ExportAssignment).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as ExportAssignment).modifiers) || - visitNode(cbNode, (node as ExportAssignment).expression); - case SyntaxKind.TemplateExpression: - return visitNode(cbNode, (node as TemplateExpression).head) || - visitNodes(cbNode, cbNodes, (node as TemplateExpression).templateSpans); - case SyntaxKind.TemplateSpan: - return visitNode(cbNode, (node as TemplateSpan).expression) || - visitNode(cbNode, (node as TemplateSpan).literal); - case SyntaxKind.TemplateLiteralType: - return visitNode(cbNode, (node as TemplateLiteralTypeNode).head) || - visitNodes(cbNode, cbNodes, (node as TemplateLiteralTypeNode).templateSpans); - case SyntaxKind.TemplateLiteralTypeSpan: - return visitNode(cbNode, (node as TemplateLiteralTypeSpan).type) || - visitNode(cbNode, (node as TemplateLiteralTypeSpan).literal); - case SyntaxKind.ComputedPropertyName: - return visitNode(cbNode, (node as ComputedPropertyName).expression); - case SyntaxKind.HeritageClause: - return visitNodes(cbNode, cbNodes, (node as HeritageClause).types); - case SyntaxKind.ExpressionWithTypeArguments: - return visitNode(cbNode, (node as ExpressionWithTypeArguments).expression) || - visitNodes(cbNode, cbNodes, (node as ExpressionWithTypeArguments).typeArguments); - case SyntaxKind.ExternalModuleReference: - return visitNode(cbNode, (node as ExternalModuleReference).expression); - case SyntaxKind.MissingDeclaration: - return visitNodes(cbNode, cbNodes, (node as MissingDeclaration).illegalDecorators) || - visitNodes(cbNode, cbNodes, (node as MissingDeclaration).modifiers); - case SyntaxKind.CommaListExpression: - return visitNodes(cbNode, cbNodes, (node as CommaListExpression).elements); - - case SyntaxKind.JsxElement: - return visitNode(cbNode, (node as JsxElement).openingElement) || - visitNodes(cbNode, cbNodes, (node as JsxElement).children) || - visitNode(cbNode, (node as JsxElement).closingElement); - case SyntaxKind.JsxFragment: - return visitNode(cbNode, (node as JsxFragment).openingFragment) || - visitNodes(cbNode, cbNodes, (node as JsxFragment).children) || - visitNode(cbNode, (node as JsxFragment).closingFragment); - case SyntaxKind.JsxSelfClosingElement: - case SyntaxKind.JsxOpeningElement: - return visitNode(cbNode, (node as JsxOpeningLikeElement).tagName) || - visitNodes(cbNode, cbNodes, (node as JsxOpeningLikeElement).typeArguments) || - visitNode(cbNode, (node as JsxOpeningLikeElement).attributes); - case SyntaxKind.JsxAttributes: - return visitNodes(cbNode, cbNodes, (node as JsxAttributes).properties); - case SyntaxKind.JsxAttribute: - return visitNode(cbNode, (node as JsxAttribute).name) || - visitNode(cbNode, (node as JsxAttribute).initializer); - case SyntaxKind.JsxSpreadAttribute: - return visitNode(cbNode, (node as JsxSpreadAttribute).expression); - case SyntaxKind.JsxExpression: - return visitNode(cbNode, (node as JsxExpression).dotDotDotToken) || - visitNode(cbNode, (node as JsxExpression).expression); - case SyntaxKind.JsxClosingElement: - return visitNode(cbNode, (node as JsxClosingElement).tagName); - - case SyntaxKind.OptionalType: - case SyntaxKind.RestType: - case SyntaxKind.JSDocTypeExpression: - case SyntaxKind.JSDocNonNullableType: - case SyntaxKind.JSDocNullableType: - case SyntaxKind.JSDocOptionalType: - case SyntaxKind.JSDocVariadicType: - return visitNode(cbNode, (node as OptionalTypeNode | RestTypeNode | JSDocTypeExpression | JSDocTypeReferencingNode).type); - case SyntaxKind.JSDocFunctionType: - return visitNodes(cbNode, cbNodes, (node as JSDocFunctionType).parameters) || - visitNode(cbNode, (node as JSDocFunctionType).type); - case SyntaxKind.JSDoc: - return (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)) - || visitNodes(cbNode, cbNodes, (node as JSDoc).tags); - case SyntaxKind.JSDocSeeTag: - return visitNode(cbNode, (node as JSDocSeeTag).tagName) || - visitNode(cbNode, (node as JSDocSeeTag).name) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocNameReference: - return visitNode(cbNode, (node as JSDocNameReference).name); - case SyntaxKind.JSDocMemberName: - return visitNode(cbNode, (node as JSDocMemberName).left) || - visitNode(cbNode, (node as JSDocMemberName).right); - case SyntaxKind.JSDocParameterTag: - case SyntaxKind.JSDocPropertyTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - ((node as JSDocPropertyLikeTag).isNameFirst - ? visitNode(cbNode, (node as JSDocPropertyLikeTag).name) || - visitNode(cbNode, (node as JSDocPropertyLikeTag).typeExpression) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)) - : visitNode(cbNode, (node as JSDocPropertyLikeTag).typeExpression) || - visitNode(cbNode, (node as JSDocPropertyLikeTag).name) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined))); - case SyntaxKind.JSDocAuthorTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocImplementsTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - visitNode(cbNode, (node as JSDocImplementsTag).class) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocAugmentsTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - visitNode(cbNode, (node as JSDocAugmentsTag).class) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocTemplateTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - visitNode(cbNode, (node as JSDocTemplateTag).constraint) || - visitNodes(cbNode, cbNodes, (node as JSDocTemplateTag).typeParameters) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocTypedefTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - ((node as JSDocTypedefTag).typeExpression && - (node as JSDocTypedefTag).typeExpression!.kind === SyntaxKind.JSDocTypeExpression - ? visitNode(cbNode, (node as JSDocTypedefTag).typeExpression) || - visitNode(cbNode, (node as JSDocTypedefTag).fullName) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)) - : visitNode(cbNode, (node as JSDocTypedefTag).fullName) || - visitNode(cbNode, (node as JSDocTypedefTag).typeExpression) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined))); - case SyntaxKind.JSDocCallbackTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - visitNode(cbNode, (node as JSDocCallbackTag).fullName) || - visitNode(cbNode, (node as JSDocCallbackTag).typeExpression) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocReturnTag: - case SyntaxKind.JSDocTypeTag: - case SyntaxKind.JSDocThisTag: - case SyntaxKind.JSDocEnumTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - visitNode(cbNode, (node as JSDocReturnTag | JSDocTypeTag | JSDocThisTag | JSDocEnumTag).typeExpression) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocSignature: - return forEach((node as JSDocSignature).typeParameters, cbNode) || - forEach((node as JSDocSignature).parameters, cbNode) || - visitNode(cbNode, (node as JSDocSignature).type); - case SyntaxKind.JSDocLink: - case SyntaxKind.JSDocLinkCode: - case SyntaxKind.JSDocLinkPlain: - return visitNode(cbNode, (node as JSDocLink | JSDocLinkCode | JSDocLinkPlain).name); - case SyntaxKind.JSDocTypeLiteral: - return forEach((node as JSDocTypeLiteral).jsDocPropertyTags, cbNode); - case SyntaxKind.JSDocTag: - case SyntaxKind.JSDocClassTag: - case SyntaxKind.JSDocPublicTag: - case SyntaxKind.JSDocPrivateTag: - case SyntaxKind.JSDocProtectedTag: - case SyntaxKind.JSDocReadonlyTag: - case SyntaxKind.JSDocDeprecatedTag: - return visitNode(cbNode, (node as JSDocTag).tagName) - || (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.PartiallyEmittedExpression: - return visitNode(cbNode, (node as PartiallyEmittedExpression).expression); - } + + const fn = (forEachChildTable as Record>)[node.kind]; + return fn === undefined ? undefined : fn(node, cbNode, cbNodes); } /** @internal */ From 3f7ff15b5f04e45caf13de5b514b471f6fac2216 Mon Sep 17 00:00:00 2001 From: TypeScript Bot Date: Mon, 22 Aug 2022 06:08:09 +0000 Subject: [PATCH 11/16] Update package-lock.json --- package-lock.json | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/package-lock.json b/package-lock.json index 8e9c292f4aea9..8e58cb5f725dd 100644 --- a/package-lock.json +++ b/package-lock.json @@ -346,12 +346,12 @@ "dev": true }, "node_modules/@octokit/plugin-paginate-rest": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-4.0.0.tgz", - "integrity": "sha512-g4GJMt/7VDmIMMdQenN6bmsmRoZca1c7IxOdF2yMiMwQYrE2bmmypGQeQSD5rsaffsFMCUS7Br4pMVZamareYA==", + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-4.1.0.tgz", + "integrity": "sha512-2O5K5fpajYG5g62wjzHR7/cWYaCA88CextAW3vFP+yoIHD0KEdlVMHfM5/i5LyV+JMmqiYW7w5qfg46FR+McNw==", "dev": true, "dependencies": { - "@octokit/types": "^7.0.0" + "@octokit/types": "^7.1.1" }, "engines": { "node": ">= 14" @@ -597,9 +597,9 @@ "dev": true }, "node_modules/@types/node": { - "version": "18.7.8", - "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.8.tgz", - "integrity": "sha512-/YP55EMK2341JkODUb8DM9O0x1SIz2aBvyF33Uf1c76St3VpsMXEIW0nxuKkq/5cxnbz0RD9cfwNZHEAZQD3ag==", + "version": "18.7.9", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.9.tgz", + "integrity": "sha512-0N5Y1XAdcl865nDdjbO0m3T6FdmQ4ijE89/urOHLREyTXbpMWbSafx9y7XIsgWGtwUP2iYTinLyyW3FatAxBLQ==", "dev": true }, "node_modules/@types/node-fetch": { @@ -8800,12 +8800,12 @@ "dev": true }, "@octokit/plugin-paginate-rest": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-4.0.0.tgz", - "integrity": "sha512-g4GJMt/7VDmIMMdQenN6bmsmRoZca1c7IxOdF2yMiMwQYrE2bmmypGQeQSD5rsaffsFMCUS7Br4pMVZamareYA==", + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-4.1.0.tgz", + "integrity": "sha512-2O5K5fpajYG5g62wjzHR7/cWYaCA88CextAW3vFP+yoIHD0KEdlVMHfM5/i5LyV+JMmqiYW7w5qfg46FR+McNw==", "dev": true, "requires": { - "@octokit/types": "^7.0.0" + "@octokit/types": "^7.1.1" } }, "@octokit/plugin-request-log": { @@ -9028,9 +9028,9 @@ "dev": true }, "@types/node": { - "version": "18.7.8", - "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.8.tgz", - "integrity": "sha512-/YP55EMK2341JkODUb8DM9O0x1SIz2aBvyF33Uf1c76St3VpsMXEIW0nxuKkq/5cxnbz0RD9cfwNZHEAZQD3ag==", + "version": "18.7.9", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.9.tgz", + "integrity": "sha512-0N5Y1XAdcl865nDdjbO0m3T6FdmQ4ijE89/urOHLREyTXbpMWbSafx9y7XIsgWGtwUP2iYTinLyyW3FatAxBLQ==", "dev": true }, "@types/node-fetch": { From aaa4f9d9ff03d7c7d304e06070612b9f84b4d683 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Mon, 22 Aug 2022 15:01:17 -0400 Subject: [PATCH 12/16] Make canHaveModifiers/Decorators public (#50399) --- src/compiler/factory/utilities.ts | 40 ------------------- src/compiler/factory/utilitiesPublic.ts | 40 +++++++++++++++++++ .../reference/api/tsserverlibrary.d.ts | 2 + tests/baselines/reference/api/typescript.d.ts | 2 + 4 files changed, 44 insertions(+), 40 deletions(-) diff --git a/src/compiler/factory/utilities.ts b/src/compiler/factory/utilities.ts index 9a02483f07dc1..9fbbdb165d22b 100644 --- a/src/compiler/factory/utilities.ts +++ b/src/compiler/factory/utilities.ts @@ -877,17 +877,6 @@ namespace ts { || kind === SyntaxKind.SetAccessor; } - export function canHaveDecorators(node: Node): node is HasDecorators { - const kind = node.kind; - return kind === SyntaxKind.Parameter - || kind === SyntaxKind.PropertyDeclaration - || kind === SyntaxKind.MethodDeclaration - || kind === SyntaxKind.GetAccessor - || kind === SyntaxKind.SetAccessor - || kind === SyntaxKind.ClassExpression - || kind === SyntaxKind.ClassDeclaration; - } - export function canHaveIllegalDecorators(node: Node): node is HasIllegalDecorators { const kind = node.kind; return kind === SyntaxKind.PropertyAssignment @@ -909,35 +898,6 @@ namespace ts { || kind === SyntaxKind.ExportAssignment; } - export function canHaveModifiers(node: Node): node is HasModifiers { - const kind = node.kind; - return kind === SyntaxKind.TypeParameter - || kind === SyntaxKind.Parameter - || kind === SyntaxKind.PropertySignature - || kind === SyntaxKind.PropertyDeclaration - || kind === SyntaxKind.MethodSignature - || kind === SyntaxKind.MethodDeclaration - || kind === SyntaxKind.Constructor - || kind === SyntaxKind.GetAccessor - || kind === SyntaxKind.SetAccessor - || kind === SyntaxKind.IndexSignature - || kind === SyntaxKind.ConstructorType - || kind === SyntaxKind.FunctionExpression - || kind === SyntaxKind.ArrowFunction - || kind === SyntaxKind.ClassExpression - || kind === SyntaxKind.VariableStatement - || kind === SyntaxKind.FunctionDeclaration - || kind === SyntaxKind.ClassDeclaration - || kind === SyntaxKind.InterfaceDeclaration - || kind === SyntaxKind.TypeAliasDeclaration - || kind === SyntaxKind.EnumDeclaration - || kind === SyntaxKind.ModuleDeclaration - || kind === SyntaxKind.ImportEqualsDeclaration - || kind === SyntaxKind.ImportDeclaration - || kind === SyntaxKind.ExportAssignment - || kind === SyntaxKind.ExportDeclaration; - } - export function canHaveIllegalModifiers(node: Node): node is HasIllegalModifiers { const kind = node.kind; return kind === SyntaxKind.ClassStaticBlockDeclaration diff --git a/src/compiler/factory/utilitiesPublic.ts b/src/compiler/factory/utilitiesPublic.ts index 9dd28667eb0e1..c51a2466ff5b2 100644 --- a/src/compiler/factory/utilitiesPublic.ts +++ b/src/compiler/factory/utilitiesPublic.ts @@ -2,4 +2,44 @@ namespace ts { export function setTextRange(range: T, location: TextRange | undefined): T { return location ? setTextRangePosEnd(range, location.pos, location.end) : range; } + + export function canHaveModifiers(node: Node): node is HasModifiers { + const kind = node.kind; + return kind === SyntaxKind.TypeParameter + || kind === SyntaxKind.Parameter + || kind === SyntaxKind.PropertySignature + || kind === SyntaxKind.PropertyDeclaration + || kind === SyntaxKind.MethodSignature + || kind === SyntaxKind.MethodDeclaration + || kind === SyntaxKind.Constructor + || kind === SyntaxKind.GetAccessor + || kind === SyntaxKind.SetAccessor + || kind === SyntaxKind.IndexSignature + || kind === SyntaxKind.ConstructorType + || kind === SyntaxKind.FunctionExpression + || kind === SyntaxKind.ArrowFunction + || kind === SyntaxKind.ClassExpression + || kind === SyntaxKind.VariableStatement + || kind === SyntaxKind.FunctionDeclaration + || kind === SyntaxKind.ClassDeclaration + || kind === SyntaxKind.InterfaceDeclaration + || kind === SyntaxKind.TypeAliasDeclaration + || kind === SyntaxKind.EnumDeclaration + || kind === SyntaxKind.ModuleDeclaration + || kind === SyntaxKind.ImportEqualsDeclaration + || kind === SyntaxKind.ImportDeclaration + || kind === SyntaxKind.ExportAssignment + || kind === SyntaxKind.ExportDeclaration; + } + + export function canHaveDecorators(node: Node): node is HasDecorators { + const kind = node.kind; + return kind === SyntaxKind.Parameter + || kind === SyntaxKind.PropertyDeclaration + || kind === SyntaxKind.MethodDeclaration + || kind === SyntaxKind.GetAccessor + || kind === SyntaxKind.SetAccessor + || kind === SyntaxKind.ClassExpression + || kind === SyntaxKind.ClassDeclaration; + } } \ No newline at end of file diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 05fed42876185..5f5edb8b2c10b 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -4834,6 +4834,8 @@ declare namespace ts { } declare namespace ts { function setTextRange(range: T, location: TextRange | undefined): T; + function canHaveModifiers(node: Node): node is HasModifiers; + function canHaveDecorators(node: Node): node is HasDecorators; } declare namespace ts { /** diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index ddaab547b5439..85470b6407cbe 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -4834,6 +4834,8 @@ declare namespace ts { } declare namespace ts { function setTextRange(range: T, location: TextRange | undefined): T; + function canHaveModifiers(node: Node): node is HasModifiers; + function canHaveDecorators(node: Node): node is HasDecorators; } declare namespace ts { /** From 6362fb2dceb9d4a6fc8640b3d82bca02961d142e Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 22 Aug 2022 13:46:03 -0700 Subject: [PATCH 13/16] Replace eslint rulesdir with eslint-plugin-local, convert eslint rules to JS (#50380) --- .eslintplugin.js | 12 +++++++ .eslintrc.json | 24 +++++++------- .npmignore | 2 ++ .vscode/settings.template.json | 6 ---- Gulpfile.js | 8 ++--- package-lock.json | 13 ++++++++ package.json | 2 +- scripts/build/prepend.js | 2 +- .../{boolean-trivia.ts => boolean-trivia.js} | 21 +++++++----- .../{debug-assert.ts => debug-assert.js} | 18 ++++++---- ...{no-double-space.ts => no-double-space.js} | 15 +++++---- .../{no-in-operator.ts => no-in-operator.js} | 9 ++--- .../rules/{no-keywords.ts => no-keywords.js} | 28 ++++++++-------- ...ace.ts => no-type-assertion-whitespace.js} | 9 ++--- ...ts => object-literal-surrounding-space.js} | 12 ++++--- ...-per-file.ts => one-namespace-per-file.js} | 12 ++++--- ...w-functions.ts => only-arrow-functions.js} | 27 +++++++-------- .../{simple-indent.ts => simple-indent.js} | 9 ++--- ...or-spacing.ts => type-operator-spacing.js} | 9 ++--- scripts/eslint/rules/utils.js | 2 ++ scripts/eslint/rules/utils.ts | 2 -- scripts/eslint/tsconfig.json | 33 ++++++++++--------- src/.eslintrc.json | 2 +- src/compiler/checker.ts | 4 +-- src/compiler/corePublic.ts | 4 +-- src/compiler/debug.ts | 4 +-- src/compiler/sourcemap.ts | 4 +-- src/compiler/tracing.ts | 4 +-- .../4.0/nodeFactoryTopLevelExports.ts | 4 +-- src/harness/fourslashImpl.ts | 4 +-- src/harness/harnessLanguageService.ts | 4 +-- src/loggedIO/loggedIO.ts | 8 ++--- src/server/project.ts | 2 +- src/services/classifier.ts | 2 +- .../codefixes/convertToAsyncFunction.ts | 2 +- src/services/findAllReferences.ts | 2 +- src/services/services.ts | 2 +- src/services/shims.ts | 4 +-- src/services/signatureHelp.ts | 4 +-- src/testRunner/parallel/host.ts | 4 +-- .../unittests/services/textChanges.ts | 18 +++++----- src/testRunner/unittests/tsserver/helpers.ts | 2 +- .../unittests/tsserver/projectReferences.ts | 4 +-- .../unittests/tsserver/webServer.ts | 2 +- 44 files changed, 200 insertions(+), 165 deletions(-) create mode 100644 .eslintplugin.js rename scripts/eslint/rules/{boolean-trivia.ts => boolean-trivia.js} (78%) rename scripts/eslint/rules/{debug-assert.ts => debug-assert.js} (72%) rename scripts/eslint/rules/{no-double-space.ts => no-double-space.js} (80%) rename scripts/eslint/rules/{no-in-operator.ts => no-in-operator.js} (70%) rename scripts/eslint/rules/{no-keywords.ts => no-keywords.js} (75%) rename scripts/eslint/rules/{no-type-assertion-whitespace.ts => no-type-assertion-whitespace.js} (78%) rename scripts/eslint/rules/{object-literal-surrounding-space.ts => object-literal-surrounding-space.js} (83%) rename scripts/eslint/rules/{one-namespace-per-file.ts => one-namespace-per-file.js} (67%) rename scripts/eslint/rules/{only-arrow-functions.ts => only-arrow-functions.js} (71%) rename scripts/eslint/rules/{simple-indent.ts => simple-indent.js} (87%) rename scripts/eslint/rules/{type-operator-spacing.ts => type-operator-spacing.js} (77%) create mode 100644 scripts/eslint/rules/utils.js delete mode 100644 scripts/eslint/rules/utils.ts diff --git a/.eslintplugin.js b/.eslintplugin.js new file mode 100644 index 0000000000000..71b2587ccda64 --- /dev/null +++ b/.eslintplugin.js @@ -0,0 +1,12 @@ +const fs = require("fs"); +const path = require("path"); + +const rulesDir = path.join(__dirname, "scripts", "eslint", "rules"); +const ext = ".js"; +const ruleFiles = fs.readdirSync(rulesDir).filter((p) => p.endsWith(ext)); + +module.exports = { + rules: Object.fromEntries(ruleFiles.map((p) => { + return [p.slice(0, -ext.length), require(path.join(rulesDir, p))]; + })), +} diff --git a/.eslintrc.json b/.eslintrc.json index 5d7deb84933d8..789725d782835 100644 --- a/.eslintrc.json +++ b/.eslintrc.json @@ -11,7 +11,7 @@ "es6": true }, "plugins": [ - "@typescript-eslint", "jsdoc", "no-null", "import" + "@typescript-eslint", "jsdoc", "no-null", "import", "eslint-plugin-local" ], "overrides": [ // By default, the ESLint CLI only looks at .js files. But, it will also look at @@ -81,20 +81,20 @@ "@typescript-eslint/unified-signatures": "error", // scripts/eslint/rules - "object-literal-surrounding-space": "error", - "no-type-assertion-whitespace": "error", - "type-operator-spacing": "error", - "only-arrow-functions": ["error", { + "local/object-literal-surrounding-space": "error", + "local/no-type-assertion-whitespace": "error", + "local/type-operator-spacing": "error", + "local/only-arrow-functions": ["error", { "allowNamedFunctions": true , "allowDeclarations": true }], - "no-double-space": "error", - "boolean-trivia": "error", - "no-in-operator": "error", - "simple-indent": "error", - "debug-assert": "error", - "no-keywords": "error", - "one-namespace-per-file": "error", + "local/no-double-space": "error", + "local/boolean-trivia": "error", + "local/no-in-operator": "error", + "local/simple-indent": "error", + "local/debug-assert": "error", + "local/no-keywords": "error", + "local/one-namespace-per-file": "error", // eslint-plugin-import "import/no-extraneous-dependencies": ["error", { "optionalDependencies": false }], diff --git a/.npmignore b/.npmignore index 55bd5fc5d4a7f..5a9f256a7dc74 100644 --- a/.npmignore +++ b/.npmignore @@ -37,3 +37,5 @@ Dockerfile .eslintrc.json .yarnrc tmp +.eslintplugin.js +.eslintcache diff --git a/.vscode/settings.template.json b/.vscode/settings.template.json index bbb5a65975578..ccfcfc2631b00 100644 --- a/.vscode/settings.template.json +++ b/.vscode/settings.template.json @@ -1,12 +1,6 @@ // Rename this file 'settings.json' or merge its // contents into your existing settings. { - "eslint.validate": [ - "typescript" - ], - "eslint.options": { - "rulePaths": ["./scripts/eslint/built/rules/"], - }, // To use the last-known-good (LKG) compiler version: // "typescript.tsdk": "lib" diff --git a/Gulpfile.js b/Gulpfile.js index 1f92049377865..7f527a93a0b57 100644 --- a/Gulpfile.js +++ b/Gulpfile.js @@ -356,7 +356,6 @@ const eslint = (folder) => async () => { "--cache", "--cache-location", `${folder}/.eslintcache`, "--format", formatter, - "--rulesdir", "scripts/eslint/built/rules", ]; if (cmdLineOptions.fix) { @@ -369,10 +368,7 @@ const eslint = (folder) => async () => { return exec(process.execPath, args); }; -const lintRoot = eslint("."); -lintRoot.displayName = "lint"; - -const lint = series([buildEslintRules, lintRoot]); +const lint = eslint("."); lint.displayName = "lint"; task("lint", lint); task("lint").description = "Runs eslint on the compiler and scripts sources."; @@ -431,7 +427,7 @@ task("watch-local").flags = { const preTest = parallel(buildTsc, buildTests, buildServices, buildLssl); preTest.displayName = "preTest"; -const postTest = (done) => cmdLineOptions.lint ? lint(done) : done(); +const postTest = (done) => cmdLineOptions.lint ? lint() : done(); const runTests = () => runConsoleTests("built/local/run.js", "mocha-fivemat-progress-reporter", /*runInParallel*/ false, /*watchMode*/ false); task("runtests", series(preBuild, preTest, runTests, postTest)); diff --git a/package-lock.json b/package-lock.json index 8e58cb5f725dd..063da0c10de9d 100644 --- a/package-lock.json +++ b/package-lock.json @@ -46,6 +46,7 @@ "eslint-formatter-autolinkable-stylish": "^1.2.0", "eslint-plugin-import": "^2.26.0", "eslint-plugin-jsdoc": "^39.3.6", + "eslint-plugin-local": "^1.0.0", "eslint-plugin-no-null": "^1.0.2", "fancy-log": "latest", "fs-extra": "^9.1.0", @@ -2523,6 +2524,12 @@ "eslint": "^7.0.0 || ^8.0.0" } }, + "node_modules/eslint-plugin-local": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-local/-/eslint-plugin-local-1.0.0.tgz", + "integrity": "sha512-bcwcQnKL/Iw5Vi/F2lG1he5oKD2OGjhsLmrcctkWrWq5TujgiaYb0cj3pZgr3XI54inNVnneOFdAx1daLoYLJQ==", + "dev": true + }, "node_modules/eslint-plugin-no-null": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/eslint-plugin-no-null/-/eslint-plugin-no-null-1.0.2.tgz", @@ -10559,6 +10566,12 @@ "spdx-expression-parse": "^3.0.1" } }, + "eslint-plugin-local": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-local/-/eslint-plugin-local-1.0.0.tgz", + "integrity": "sha512-bcwcQnKL/Iw5Vi/F2lG1he5oKD2OGjhsLmrcctkWrWq5TujgiaYb0cj3pZgr3XI54inNVnneOFdAx1daLoYLJQ==", + "dev": true + }, "eslint-plugin-no-null": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/eslint-plugin-no-null/-/eslint-plugin-no-null-1.0.2.tgz", diff --git a/package.json b/package.json index 569938200e734..30513a47bc9fc 100644 --- a/package.json +++ b/package.json @@ -62,6 +62,7 @@ "eslint-formatter-autolinkable-stylish": "^1.2.0", "eslint-plugin-import": "^2.26.0", "eslint-plugin-jsdoc": "^39.3.6", + "eslint-plugin-local": "^1.0.0", "eslint-plugin-no-null": "^1.0.2", "fancy-log": "latest", "fs-extra": "^9.1.0", @@ -90,7 +91,6 @@ "es5-ext": "0.10.53" }, "scripts": { - "prepare": "gulp build-eslint-rules", "pretest": "gulp tests", "test": "gulp runtests-parallel --light=false", "test:eslint-rules": "gulp run-eslint-rules-tests", diff --git a/scripts/build/prepend.js b/scripts/build/prepend.js index d0f103ba4aa34..d7571efdaabdb 100644 --- a/scripts/build/prepend.js +++ b/scripts/build/prepend.js @@ -42,7 +42,7 @@ function prepend(data) { sourcesContent: input.sourcesContent }; } - // eslint-disable-next-line boolean-trivia, no-null/no-null + // eslint-disable-next-line local/boolean-trivia, no-null/no-null return cb(null, output); } catch (e) { diff --git a/scripts/eslint/rules/boolean-trivia.ts b/scripts/eslint/rules/boolean-trivia.js similarity index 78% rename from scripts/eslint/rules/boolean-trivia.ts rename to scripts/eslint/rules/boolean-trivia.js index 2b343da8e17b2..2aa38ab04c284 100644 --- a/scripts/eslint/rules/boolean-trivia.ts +++ b/scripts/eslint/rules/boolean-trivia.js @@ -1,7 +1,7 @@ -import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils"; -import { createRule } from "./utils"; +const { AST_NODE_TYPES, TSESTree } = require("@typescript-eslint/utils"); +const { createRule } = require("./utils"); -export = createRule({ +module.exports = createRule({ name: "boolean-trivia", meta: { docs: { @@ -21,8 +21,10 @@ export = createRule({ const sourceCode = context.getSourceCode(); const sourceCodeText = sourceCode.getText(); - const isSetOrAssert = (name: string): boolean => name.startsWith("set") || name.startsWith("assert"); - const isTrivia = (node: TSESTree.Node): boolean => { + /** @type {(name: string) => boolean} */ + const isSetOrAssert = (name) => name.startsWith("set") || name.startsWith("assert"); + /** @type {(node: TSESTree.Node) => boolean} */ + const isTrivia = (node) => { if (node.type === AST_NODE_TYPES.Identifier) { return node.name === "undefined"; } @@ -35,7 +37,8 @@ export = createRule({ return false; }; - const shouldIgnoreCalledExpression = (node: TSESTree.CallExpression): boolean => { + /** @type {(node: TSESTree.CallExpression) => boolean} */ + const shouldIgnoreCalledExpression = (node) => { if (node.callee && node.callee.type === AST_NODE_TYPES.MemberExpression) { const methodName = node.callee.property.type === AST_NODE_TYPES.Identifier ? node.callee.property.name @@ -68,7 +71,8 @@ export = createRule({ return false; }; - const checkArg = (node: TSESTree.Node): void => { + /** @type {(node: TSESTree.Node) => void} */ + const checkArg = (node) => { if (!isTrivia(node)) { return; } @@ -88,7 +92,8 @@ export = createRule({ } }; - const checkBooleanTrivia = (node: TSESTree.CallExpression) => { + /** @type {(node: TSESTree.CallExpression) => void} */ + const checkBooleanTrivia = (node) => { if (shouldIgnoreCalledExpression(node)) { return; } diff --git a/scripts/eslint/rules/debug-assert.ts b/scripts/eslint/rules/debug-assert.js similarity index 72% rename from scripts/eslint/rules/debug-assert.ts rename to scripts/eslint/rules/debug-assert.js index 3c07229f4c574..5d416afbd2565 100644 --- a/scripts/eslint/rules/debug-assert.ts +++ b/scripts/eslint/rules/debug-assert.js @@ -1,7 +1,7 @@ -import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils"; -import { createRule } from "./utils"; +const { AST_NODE_TYPES, TSESTree } = require("@typescript-eslint/utils"); +const { createRule } = require("./utils"); -export = createRule({ +module.exports = createRule({ name: "debug-assert", meta: { docs: { @@ -18,19 +18,23 @@ export = createRule({ defaultOptions: [], create(context) { - const isArrowFunction = (node: TSESTree.Node) => node.type === AST_NODE_TYPES.ArrowFunctionExpression; - const isStringLiteral = (node: TSESTree.Node): boolean => ( + /** @type {(node: TSESTree.Node) => boolean} */ + const isArrowFunction = (node) => node.type === AST_NODE_TYPES.ArrowFunctionExpression; + /** @type {(node: TSESTree.Node) => boolean} */ + const isStringLiteral = (node) => ( (node.type === AST_NODE_TYPES.Literal && typeof node.value === "string") || node.type === AST_NODE_TYPES.TemplateLiteral ); - const isDebugAssert = (node: TSESTree.MemberExpression): boolean => ( + /** @type {(node: TSESTree.MemberExpression) => boolean} */ + const isDebugAssert = (node) => ( node.object.type === AST_NODE_TYPES.Identifier && node.object.name === "Debug" && node.property.type === AST_NODE_TYPES.Identifier && node.property.name === "assert" ); - const checkDebugAssert = (node: TSESTree.CallExpression) => { + /** @type {(node: TSESTree.CallExpression) => void} */ + const checkDebugAssert = (node) => { const args = node.arguments; const argsLen = args.length; if (!(node.callee.type === AST_NODE_TYPES.MemberExpression && isDebugAssert(node.callee)) || argsLen < 2) { diff --git a/scripts/eslint/rules/no-double-space.ts b/scripts/eslint/rules/no-double-space.js similarity index 80% rename from scripts/eslint/rules/no-double-space.ts rename to scripts/eslint/rules/no-double-space.js index 537e9a6caf9df..1845486edc78e 100644 --- a/scripts/eslint/rules/no-double-space.ts +++ b/scripts/eslint/rules/no-double-space.js @@ -1,7 +1,7 @@ -import { TSESTree, AST_NODE_TYPES } from "@typescript-eslint/utils"; -import { createRule } from "./utils"; +const { TSESTree, AST_NODE_TYPES } = require("@typescript-eslint/utils"); +const { createRule } = require("./utils"); -export = createRule({ +module.exports = createRule({ name: "no-double-space", meta: { docs: { @@ -20,7 +20,8 @@ export = createRule({ const sourceCode = context.getSourceCode(); const lines = sourceCode.getLines(); - const isStringLiteral = (node: TSESTree.Node | null): boolean => { + /** @type {(node: TSESTree.Node | null) => boolean} */ + const isStringLiteral = (node) => { return !!(node && ( (node.type === AST_NODE_TYPES.TemplateElement) || (node.type === AST_NODE_TYPES.TemplateLiteral && node.quasis) || @@ -28,11 +29,13 @@ export = createRule({ )); }; - const isRegexLiteral = (node: TSESTree.Node | null): boolean => { + /** @type {(node: TSESTree.Node | null) => boolean} */ + const isRegexLiteral = (node) => { return !!(node && node.type === AST_NODE_TYPES.Literal && Object.prototype.hasOwnProperty.call(node, "regex")); }; - const checkDoubleSpace = (node: TSESTree.Node) => { + /** @type {(node: TSESTree.Node) => void} */ + const checkDoubleSpace = (node) => { lines.forEach((line, index) => { const firstNonSpace = /\S/.exec(line); if (!firstNonSpace || line.includes("@param")) { diff --git a/scripts/eslint/rules/no-in-operator.ts b/scripts/eslint/rules/no-in-operator.js similarity index 70% rename from scripts/eslint/rules/no-in-operator.ts rename to scripts/eslint/rules/no-in-operator.js index de1b89157ec48..c93000e307518 100644 --- a/scripts/eslint/rules/no-in-operator.ts +++ b/scripts/eslint/rules/no-in-operator.js @@ -1,7 +1,7 @@ -import { TSESTree } from "@typescript-eslint/utils"; -import { createRule } from "./utils"; +const { TSESTree } = require("@typescript-eslint/utils"); +const { createRule } = require("./utils"); -export = createRule({ +module.exports = createRule({ name: "no-in-operator", meta: { docs: { @@ -18,7 +18,8 @@ export = createRule({ create(context) { const IN_OPERATOR = "in"; - const checkInOperator = (node: TSESTree.BinaryExpression) => { + /** @type {(node: TSESTree.BinaryExpression) => void} */ + const checkInOperator = (node) => { if (node.operator === IN_OPERATOR) { context.report({ messageId: "noInOperatorError", node }); } diff --git a/scripts/eslint/rules/no-keywords.ts b/scripts/eslint/rules/no-keywords.js similarity index 75% rename from scripts/eslint/rules/no-keywords.ts rename to scripts/eslint/rules/no-keywords.js index 146739743be53..00b18b598e575 100644 --- a/scripts/eslint/rules/no-keywords.ts +++ b/scripts/eslint/rules/no-keywords.js @@ -1,7 +1,7 @@ -import { TSESTree, AST_NODE_TYPES } from "@typescript-eslint/utils"; -import { createRule } from "./utils"; +const { TSESTree, AST_NODE_TYPES } = require("@typescript-eslint/utils"); +const { createRule } = require("./utils"); -export = createRule({ +module.exports = createRule({ name: "no-keywords", meta: { docs: { @@ -35,13 +35,16 @@ export = createRule({ "any", ]; - const isKeyword = (name: string) => keywords.includes(name); + /** @type {(name: string) => boolean} */ + const isKeyword = (name) => keywords.includes(name); - const report = (node: TSESTree.Identifier) => { + /** @type {(node: TSESTree.Identifier) => void} */ + const report = (node) => { context.report({ messageId: "noKeywordsError", data: { name: node.name }, node }); }; - const checkProperties = (node: TSESTree.ObjectPattern): void => { + /** @type {(node: TSESTree.ObjectPattern) => void} */ + const checkProperties = (node) => { node.properties.forEach(property => { if ( property && @@ -54,7 +57,8 @@ export = createRule({ }); }; - const checkElements = (node: TSESTree.ArrayPattern): void => { + /** @type {(node: TSESTree.ArrayPattern) => void} */ + const checkElements = (node) => { node.elements.forEach(element => { if ( element && @@ -66,14 +70,8 @@ export = createRule({ }); }; - const checkParams = ( - node: - | TSESTree.ArrowFunctionExpression - | TSESTree.FunctionDeclaration - | TSESTree.FunctionExpression - | TSESTree.TSMethodSignature - | TSESTree.TSFunctionType - ): void => { + /** @type {(node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.TSMethodSignature | TSESTree.TSFunctionType) => void} */ + const checkParams = (node) => { if (!node || !node.params || !node.params.length) { return; } diff --git a/scripts/eslint/rules/no-type-assertion-whitespace.ts b/scripts/eslint/rules/no-type-assertion-whitespace.js similarity index 78% rename from scripts/eslint/rules/no-type-assertion-whitespace.ts rename to scripts/eslint/rules/no-type-assertion-whitespace.js index 7607d96ad296e..f107d234f6e17 100644 --- a/scripts/eslint/rules/no-type-assertion-whitespace.ts +++ b/scripts/eslint/rules/no-type-assertion-whitespace.js @@ -1,7 +1,7 @@ -import { TSESTree } from "@typescript-eslint/utils"; -import { createRule } from "./utils"; +const { TSESTree } = require("@typescript-eslint/utils"); +const { createRule } = require("./utils"); -export = createRule({ +module.exports = createRule({ name: "no-type-assertion-whitespace", meta: { docs: { @@ -18,7 +18,8 @@ export = createRule({ create(context) { const sourceCode = context.getSourceCode(); - const checkTypeAssertionWhitespace = (node: TSESTree.TSTypeAssertion) => { + /** @type {(node: TSESTree.TSTypeAssertion) => void} */ + const checkTypeAssertionWhitespace = (node) => { const leftToken = sourceCode.getLastToken(node.typeAnnotation); const rightToken = sourceCode.getFirstToken(node.expression); diff --git a/scripts/eslint/rules/object-literal-surrounding-space.ts b/scripts/eslint/rules/object-literal-surrounding-space.js similarity index 83% rename from scripts/eslint/rules/object-literal-surrounding-space.ts rename to scripts/eslint/rules/object-literal-surrounding-space.js index 32a10ebbd878e..2a04ae20f136c 100644 --- a/scripts/eslint/rules/object-literal-surrounding-space.ts +++ b/scripts/eslint/rules/object-literal-surrounding-space.js @@ -1,7 +1,7 @@ -import { TSESTree } from "@typescript-eslint/utils"; -import { createRule } from "./utils"; +const { TSESTree } = require("@typescript-eslint/utils"); +const { createRule } = require("./utils"); -export = createRule({ +module.exports = createRule({ name: "object-literal-surrounding-space", meta: { docs: { @@ -26,11 +26,13 @@ export = createRule({ const CLOSE_SYMBOL = "}"; const OPEN_SYMBOL = "{"; - const manySpaces = (text: string, startIndex: number): boolean => ( + /** @type {(text: string, startIndex: number) => boolean} */ + const manySpaces = (text, startIndex) => ( [startIndex, startIndex + 1].every(i => text.charAt(i) === SPACE_SYMBOL) ); - const checkObjectLiteralSurroundingSpace = (node: TSESTree.ObjectExpression) => { + /** @type {(node: TSESTree.ObjectExpression) => void} */ + const checkObjectLiteralSurroundingSpace = (node) => { const text = sourceCode.getText(node); const startLine = node.loc.start.line; const endLine = node.loc.end.line; diff --git a/scripts/eslint/rules/one-namespace-per-file.ts b/scripts/eslint/rules/one-namespace-per-file.js similarity index 67% rename from scripts/eslint/rules/one-namespace-per-file.ts rename to scripts/eslint/rules/one-namespace-per-file.js index cb98d43a7d553..a91f54eeafcf1 100644 --- a/scripts/eslint/rules/one-namespace-per-file.ts +++ b/scripts/eslint/rules/one-namespace-per-file.js @@ -1,7 +1,7 @@ -import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils"; -import { createRule } from "./utils"; +const { AST_NODE_TYPES, TSESTree } = require("@typescript-eslint/utils"); +const { createRule } = require("./utils"); -export = createRule({ +module.exports = createRule({ name: "one-namespace-per-file", meta: { docs: { @@ -17,9 +17,11 @@ export = createRule({ defaultOptions: [], create(context) { - const isNamespaceDeclaration = (node: TSESTree.Node): node is TSESTree.TSModuleDeclaration => node.type === AST_NODE_TYPES.TSModuleDeclaration; + /** @type {(node: TSESTree.Node) => node is TSESTree.TSModuleDeclaration} */ + const isNamespaceDeclaration = (node) => node.type === AST_NODE_TYPES.TSModuleDeclaration; - const checkSourceFile = (node: TSESTree.Program) => { + /** @type {(node: TSESTree.Program) => void} */ + const checkSourceFile = (node) => { if (context.getFilename().endsWith(".d.ts")) { return; } diff --git a/scripts/eslint/rules/only-arrow-functions.ts b/scripts/eslint/rules/only-arrow-functions.js similarity index 71% rename from scripts/eslint/rules/only-arrow-functions.ts rename to scripts/eslint/rules/only-arrow-functions.js index 1d61d14815772..a97673b08d32a 100644 --- a/scripts/eslint/rules/only-arrow-functions.ts +++ b/scripts/eslint/rules/only-arrow-functions.js @@ -1,13 +1,7 @@ -import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils"; -import { createRule } from "./utils"; +const { AST_NODE_TYPES, TSESTree } = require("@typescript-eslint/utils"); +const { createRule } = require("./utils"); -type MessageId = "onlyArrowFunctionsError"; -type Options = [{ - allowNamedFunctions?: boolean; - allowDeclarations?: boolean; -}]; - -export = createRule({ +module.exports = createRule({ name: "only-arrow-functions", meta: { docs: { @@ -27,6 +21,7 @@ export = createRule({ }], type: "suggestion", }, + /** @type {[{ allowNamedFunctions?: boolean; allowDeclarations?: boolean }]} */ defaultOptions: [{ allowNamedFunctions: false, allowDeclarations: false, @@ -34,11 +29,11 @@ export = createRule({ create(context, [{ allowNamedFunctions, allowDeclarations }]) { - const isThisParameter = (node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression) => ( - node.params.length && !!node.params.find(param => param.type === AST_NODE_TYPES.Identifier && param.name === "this") - ); + /** @type {(node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression) => boolean} */ + const isThisParameter = (node) => !!node.params.length && !!node.params.find(param => param.type === AST_NODE_TYPES.Identifier && param.name === "this"); - const isMethodType = (node: TSESTree.Node) => { + /** @type {(node: TSESTree.Node) => boolean} */ + const isMethodType = (node) => { const types = [ AST_NODE_TYPES.MethodDefinition, AST_NODE_TYPES.Property, @@ -52,7 +47,8 @@ export = createRule({ return node.type === AST_NODE_TYPES.FunctionExpression && types.includes(parent.type); }; - const stack: boolean[] = []; + /** @type {boolean[]} */ + const stack = []; const enterFunction = () => { stack.push(false); }; @@ -63,7 +59,8 @@ export = createRule({ } }; - const exitFunction = (node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression) => { + /** @type {(node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression) => void} */ + const exitFunction = (node) => { const methodUsesThis = stack.pop(); if (node.type === AST_NODE_TYPES.FunctionDeclaration && allowDeclarations) { diff --git a/scripts/eslint/rules/simple-indent.ts b/scripts/eslint/rules/simple-indent.js similarity index 87% rename from scripts/eslint/rules/simple-indent.ts rename to scripts/eslint/rules/simple-indent.js index 2db3dfeb1a81c..fc41e21cd19f6 100644 --- a/scripts/eslint/rules/simple-indent.ts +++ b/scripts/eslint/rules/simple-indent.js @@ -1,7 +1,7 @@ -import { TSESTree } from "@typescript-eslint/utils"; -import { createRule } from "./utils"; +const { TSESTree } = require("@typescript-eslint/utils"); +const { createRule } = require("./utils"); -export = createRule({ +module.exports = createRule({ name: "simple-indent", meta: { docs: { @@ -22,7 +22,8 @@ export = createRule({ const sourceCode = context.getSourceCode(); const linebreaks = sourceCode.getText().match(/\r\n|[\r\n\u2028\u2029]/gu); - const checkIndent = (node: TSESTree.Program) => { + /** @type {(node: TSESTree.Program) => void} */ + const checkIndent = (node) => { const lines = sourceCode.getLines(); const linesLen = lines.length; diff --git a/scripts/eslint/rules/type-operator-spacing.ts b/scripts/eslint/rules/type-operator-spacing.js similarity index 77% rename from scripts/eslint/rules/type-operator-spacing.ts rename to scripts/eslint/rules/type-operator-spacing.js index b7817812a5ee6..1df853da6a330 100644 --- a/scripts/eslint/rules/type-operator-spacing.ts +++ b/scripts/eslint/rules/type-operator-spacing.js @@ -1,7 +1,7 @@ -import { TSESTree, AST_TOKEN_TYPES } from "@typescript-eslint/utils"; -import { createRule } from "./utils"; +const { TSESTree, AST_TOKEN_TYPES } = require("@typescript-eslint/utils"); +const { createRule } = require("./utils"); -export = createRule({ +module.exports = createRule({ name: "type-operator-spacing", meta: { docs: { @@ -21,7 +21,8 @@ export = createRule({ const tokens = ["|", "&"]; const text = sourceCode.getText(); - const checkTypeOperatorSpacing = (node: TSESTree.TSIntersectionType | TSESTree.TSUnionType) => { + /** @type {(node: TSESTree.TSIntersectionType | TSESTree.TSUnionType) => void} */ + const checkTypeOperatorSpacing = (node) => { node.types.forEach(node => { const token = sourceCode.getTokenBefore(node); diff --git a/scripts/eslint/rules/utils.js b/scripts/eslint/rules/utils.js new file mode 100644 index 0000000000000..e96840b481f92 --- /dev/null +++ b/scripts/eslint/rules/utils.js @@ -0,0 +1,2 @@ +const { ESLintUtils } = require("@typescript-eslint/utils"); +module.exports.createRule = ESLintUtils.RuleCreator(() => ""); diff --git a/scripts/eslint/rules/utils.ts b/scripts/eslint/rules/utils.ts deleted file mode 100644 index cc2aa108b7846..0000000000000 --- a/scripts/eslint/rules/utils.ts +++ /dev/null @@ -1,2 +0,0 @@ -import { ESLintUtils } from "@typescript-eslint/utils"; -export const createRule = ESLintUtils.RuleCreator(() => ""); diff --git a/scripts/eslint/tsconfig.json b/scripts/eslint/tsconfig.json index 254e074b11bef..a9994669e63eb 100644 --- a/scripts/eslint/tsconfig.json +++ b/scripts/eslint/tsconfig.json @@ -1,23 +1,26 @@ { "compilerOptions": { - "forceConsistentCasingInFileNames": true, - "suppressImplicitAnyIndexErrors": true, - "experimentalDecorators": true, - "noImplicitReturns": true, - "resolveJsonModule": true, - "moduleResolution": "node", - "esModuleInterop": true, - "noImplicitThis": true, - "noUnusedLocals": true, - "noImplicitAny": true, - "skipLibCheck": true, - "declaration": false, - "noResolve": false, - "strict": true, + "lib": [ + "es6" + ], "module": "commonjs", "target": "es6", "outDir": "./built", - "lib": ["es2015", "es2016"] + "declaration": false, + + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "moduleResolution": "node", + "allowUnusedLabels": false, + "noImplicitOverride": true, + "noImplicitReturns": true, + "noPropertyAccessFromIndexSignature": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "allowJs": true, + "checkJs": true }, "include": [ diff --git a/src/.eslintrc.json b/src/.eslintrc.json index 78ef6cc969263..f7ec4c8a8f555 100644 --- a/src/.eslintrc.json +++ b/src/.eslintrc.json @@ -17,7 +17,7 @@ "@typescript-eslint/unified-signatures": "off", // scripts/eslint/rules - "no-keywords": "off", + "local/no-keywords": "off", // eslint "no-var": "off" diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 939f82cca0ad9..8472c8b38e7e5 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1206,10 +1206,10 @@ namespace ts { } // Issue errors globally const file = getSourceFileOfNode(location); - addErrorOrSuggestion(isError, "message" in message ? createFileDiagnostic(file, 0, 0, message, arg0, arg1, arg2, arg3) : createDiagnosticForFileFromMessageChain(file, message)); // eslint-disable-line no-in-operator + addErrorOrSuggestion(isError, "message" in message ? createFileDiagnostic(file, 0, 0, message, arg0, arg1, arg2, arg3) : createDiagnosticForFileFromMessageChain(file, message)); // eslint-disable-line local/no-in-operator return; } - addErrorOrSuggestion(isError, "message" in message ? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : createDiagnosticForNodeFromMessageChain(location, message)); // eslint-disable-line no-in-operator + addErrorOrSuggestion(isError, "message" in message ? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : createDiagnosticForNodeFromMessageChain(location, message)); // eslint-disable-line local/no-in-operator } function errorAndMaybeSuggestAwait( diff --git a/src/compiler/corePublic.ts b/src/compiler/corePublic.ts index 45f307824027a..b13857a27fb77 100644 --- a/src/compiler/corePublic.ts +++ b/src/compiler/corePublic.ts @@ -127,7 +127,7 @@ namespace ts { export function tryGetNativeMap(): MapConstructor { // Internet Explorer's Map doesn't support iteration, so don't use it. const gMap = globals?.Map; - // eslint-disable-next-line no-in-operator + // eslint-disable-next-line local/no-in-operator const constructor = typeof gMap !== "undefined" && "entries" in gMap.prototype && new gMap([[0, 0]]).size === 1 ? gMap : undefined; if (!constructor) { throw new Error("No compatible Map implementation found."); @@ -141,7 +141,7 @@ namespace ts { export function tryGetNativeSet(): SetConstructor { // Internet Explorer's Set doesn't support iteration, so don't use it. const gSet = globals?.Set; - // eslint-disable-next-line no-in-operator + // eslint-disable-next-line local/no-in-operator const constructor = typeof gSet !== "undefined" && "entries" in gSet.prototype && new gSet([0]).size === 1 ? gSet : undefined; if (!constructor) { throw new Error("No compatible Set implementation found."); diff --git a/src/compiler/debug.ts b/src/compiler/debug.ts index c48b1114cb4a1..d6edd94b3dc49 100644 --- a/src/compiler/debug.ts +++ b/src/compiler/debug.ts @@ -439,7 +439,7 @@ namespace ts { let flowNodeProto: FlowNodeBase | undefined; function attachFlowNodeDebugInfoWorker(flowNode: FlowNodeBase) { - if (!("__debugFlowFlags" in flowNode)) { // eslint-disable-line no-in-operator + if (!("__debugFlowFlags" in flowNode)) { // eslint-disable-line local/no-in-operator Object.defineProperties(flowNode, { // for use with vscode-js-debug's new customDescriptionGenerator in launch.json __tsDebuggerDisplay: { @@ -488,7 +488,7 @@ namespace ts { let nodeArrayProto: NodeArray | undefined; function attachNodeArrayDebugInfoWorker(array: NodeArray) { - if (!("__tsDebuggerDisplay" in array)) { // eslint-disable-line no-in-operator + if (!("__tsDebuggerDisplay" in array)) { // eslint-disable-line local/no-in-operator Object.defineProperties(array, { __tsDebuggerDisplay: { value(this: NodeArray, defaultValue: string) { diff --git a/src/compiler/sourcemap.ts b/src/compiler/sourcemap.ts index e3aebc849b6a3..af22d1905e87f 100644 --- a/src/compiler/sourcemap.ts +++ b/src/compiler/sourcemap.ts @@ -69,7 +69,7 @@ namespace ts { return sourceIndex; } - /* eslint-disable boolean-trivia, no-null/no-null */ + /* eslint-disable local/boolean-trivia, no-null/no-null */ function setSourceContent(sourceIndex: number, content: string | null) { enter(); if (content !== null) { @@ -81,7 +81,7 @@ namespace ts { } exit(); } - /* eslint-enable boolean-trivia, no-null/no-null */ + /* eslint-enable local/boolean-trivia, no-null/no-null */ function addName(name: string) { enter(); diff --git a/src/compiler/tracing.ts b/src/compiler/tracing.ts index 25765b7362a55..3fe7e335c7b35 100644 --- a/src/compiler/tracing.ts +++ b/src/compiler/tracing.ts @@ -1,13 +1,13 @@ /* Tracing events for the compiler. */ /*@internal*/ -namespace ts { // eslint-disable-line one-namespace-per-file +namespace ts { // eslint-disable-line local/one-namespace-per-file // should be used as tracing?.___ export let tracing: typeof tracingEnabled | undefined; // enable the above using startTracing() // `tracingEnabled` should never be used directly, only through the above - namespace tracingEnabled { // eslint-disable-line one-namespace-per-file + namespace tracingEnabled { // eslint-disable-line local/one-namespace-per-file type Mode = "project" | "build" | "server"; let fs: typeof import("fs"); diff --git a/src/deprecatedCompat/4.0/nodeFactoryTopLevelExports.ts b/src/deprecatedCompat/4.0/nodeFactoryTopLevelExports.ts index 07dccb1e1c6a7..6b14268806cdf 100644 --- a/src/deprecatedCompat/4.0/nodeFactoryTopLevelExports.ts +++ b/src/deprecatedCompat/4.0/nodeFactoryTopLevelExports.ts @@ -965,7 +965,7 @@ namespace ts { if (typeof value === "number") { return factory.createNumericLiteral(value); } - // eslint-disable-next-line no-in-operator + // eslint-disable-next-line local/no-in-operator if (typeof value === "object" && "base10Value" in value) { // PseudoBigInt return factory.createBigIntLiteral(value); } @@ -1303,4 +1303,4 @@ namespace ts { setParent(clone, node.parent); return clone; }, { since: "4.0", warnAfter: "4.1", message: "Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`." }); -} \ No newline at end of file +} diff --git a/src/harness/fourslashImpl.ts b/src/harness/fourslashImpl.ts index d0ed9fd6c03af..46d2bc242e772 100644 --- a/src/harness/fourslashImpl.ts +++ b/src/harness/fourslashImpl.ts @@ -1452,7 +1452,7 @@ namespace FourSlash { const sort = (locations: readonly ts.RenameLocation[] | undefined) => locations && ts.sort(locations, (r1, r2) => ts.compareStringsCaseSensitive(r1.fileName, r2.fileName) || r1.textSpan.start - r2.textSpan.start); assert.deepEqual(sort(references), sort(ranges.map((rangeOrOptions): ts.RenameLocation => { - const { range, ...prefixSuffixText } = "range" in rangeOrOptions ? rangeOrOptions : { range: rangeOrOptions }; // eslint-disable-line no-in-operator + const { range, ...prefixSuffixText } = "range" in rangeOrOptions ? rangeOrOptions : { range: rangeOrOptions }; // eslint-disable-line local/no-in-operator const { contextRangeIndex, contextRangeDelta, contextRangeId } = (range.marker && range.marker.data || {}) as RangeMarkerData; let contextSpan: ts.TextSpan | undefined; if (contextRangeDelta !== undefined) { @@ -3923,7 +3923,7 @@ namespace FourSlash { return this.getApplicableRefactorsWorker(this.getSelection(), this.activeFile.fileName, preferences, triggerReason, kind); } private getApplicableRefactors(rangeOrMarker: Range | Marker, preferences = ts.emptyOptions, triggerReason: ts.RefactorTriggerReason = "implicit", kind?: string): readonly ts.ApplicableRefactorInfo[] { - return this.getApplicableRefactorsWorker("position" in rangeOrMarker ? rangeOrMarker.position : rangeOrMarker, rangeOrMarker.fileName, preferences, triggerReason, kind); // eslint-disable-line no-in-operator + return this.getApplicableRefactorsWorker("position" in rangeOrMarker ? rangeOrMarker.position : rangeOrMarker, rangeOrMarker.fileName, preferences, triggerReason, kind); // eslint-disable-line local/no-in-operator } private getApplicableRefactorsWorker(positionOrRange: number | ts.TextRange, fileName: string, preferences = ts.emptyOptions, triggerReason: ts.RefactorTriggerReason, kind?: string): readonly ts.ApplicableRefactorInfo[] { return this.languageService.getApplicableRefactors(fileName, positionOrRange, preferences, triggerReason, kind) || ts.emptyArray; diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts index 3497d9acf5bc8..6003a2ad6ce2a 100644 --- a/src/harness/harnessLanguageService.ts +++ b/src/harness/harnessLanguageService.ts @@ -4,7 +4,7 @@ namespace Harness.LanguageService { const proxy = Object.create(/*prototype*/ null); // eslint-disable-line no-null/no-null const langSvc: any = info.languageService; for (const k of Object.keys(langSvc)) { - // eslint-disable-next-line only-arrow-functions + // eslint-disable-next-line local/only-arrow-functions proxy[k] = function () { return langSvc[k].apply(langSvc, arguments); }; @@ -886,7 +886,7 @@ namespace Harness.LanguageService { create(info: ts.server.PluginCreateInfo) { const proxy = makeDefaultProxy(info); const langSvc: any = info.languageService; - // eslint-disable-next-line only-arrow-functions + // eslint-disable-next-line local/only-arrow-functions proxy.getQuickInfoAtPosition = function () { const parts = langSvc.getQuickInfoAtPosition.apply(langSvc, arguments); if (parts.displayParts.length > 0) { diff --git a/src/loggedIO/loggedIO.ts b/src/loggedIO/loggedIO.ts index fdd8c91906d87..24b3f815f605e 100644 --- a/src/loggedIO/loggedIO.ts +++ b/src/loggedIO/loggedIO.ts @@ -1,4 +1,4 @@ -namespace Playback { // eslint-disable-line one-namespace-per-file +namespace Playback { // eslint-disable-line local/one-namespace-per-file interface FileInformation { contents?: string; contentsPath?: string; @@ -361,7 +361,7 @@ namespace Playback { // eslint-disable-line one-namespace-per-file function recordReplay(original: T, underlying: any) { function createWrapper(record: T, replay: T): T { - // eslint-disable-next-line only-arrow-functions + // eslint-disable-next-line local/only-arrow-functions return (function () { if (replayLog !== undefined) { return replay.apply(undefined, arguments); @@ -447,5 +447,5 @@ namespace Playback { // eslint-disable-line one-namespace-per-file } // empty modules for the module migration script -namespace ts.server { } // eslint-disable-line one-namespace-per-file -namespace Harness { } // eslint-disable-line one-namespace-per-file +namespace ts.server { } // eslint-disable-line local/one-namespace-per-file +namespace Harness { } // eslint-disable-line local/one-namespace-per-file diff --git a/src/server/project.ts b/src/server/project.ts index 1a27b63d2eaa2..28dbeb66303dc 100644 --- a/src/server/project.ts +++ b/src/server/project.ts @@ -1721,7 +1721,7 @@ namespace ts.server { const pluginModule = pluginModuleFactory({ typescript: ts }); const newLS = pluginModule.create(info); for (const k of Object.keys(this.languageService)) { - // eslint-disable-next-line no-in-operator + // eslint-disable-next-line local/no-in-operator if (!(k in newLS)) { this.projectService.logger.info(`Plugin activation warning: Missing proxied method ${k} in created LS. Patching.`); (newLS as any)[k] = (this.languageService as any)[k]; diff --git a/src/services/classifier.ts b/src/services/classifier.ts index ed8445b8f3987..1b6705efed820 100644 --- a/src/services/classifier.ts +++ b/src/services/classifier.ts @@ -819,7 +819,7 @@ namespace ts { // defined in `ts.commentPragmas` would be excessive, but we can avoid // some obvious false positives (e.g. in XML-like doc comments) by // checking the element name. - // eslint-disable-next-line no-in-operator + // eslint-disable-next-line local/no-in-operator if (!match[3] || !(match[3] in commentPragmas)) { return false; } diff --git a/src/services/codefixes/convertToAsyncFunction.ts b/src/services/codefixes/convertToAsyncFunction.ts index 8b7282ee5f102..cf633747320fc 100644 --- a/src/services/codefixes/convertToAsyncFunction.ts +++ b/src/services/codefixes/convertToAsyncFunction.ts @@ -754,7 +754,7 @@ namespace ts.codefix { } // return undefined argName when arg is null or undefined - // eslint-disable-next-line no-in-operator + // eslint-disable-next-line local/no-in-operator if (!name || "identifier" in name && name.identifier.text === "undefined") { return undefined; } diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index 6caef92ac12f3..d11a447b1428b 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -1725,7 +1725,7 @@ namespace ts.FindAllReferences { } function addReference(referenceLocation: Node, relatedSymbol: Symbol | RelatedSymbol, state: State): void { - const { kind, symbol } = "kind" in relatedSymbol ? relatedSymbol : { kind: undefined, symbol: relatedSymbol }; // eslint-disable-line no-in-operator + const { kind, symbol } = "kind" in relatedSymbol ? relatedSymbol : { kind: undefined, symbol: relatedSymbol }; // eslint-disable-line local/no-in-operator // if rename symbol from default export anonymous function, for example `export default function() {}`, we do not need to add reference if (state.options.use === FindReferencesUse.Rename && referenceLocation.kind === SyntaxKind.DefaultKeyword) { diff --git a/src/services/services.ts b/src/services/services.ts index 15540e28acf99..a2078b875a568 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -36,7 +36,7 @@ namespace ts { } private assertHasRealPosition(message?: string) { - // eslint-disable-next-line debug-assert + // eslint-disable-next-line local/debug-assert Debug.assert(!positionIsSynthesized(this.pos) && !positionIsSynthesized(this.end), message || "Node must have a real position for this operation"); } diff --git a/src/services/shims.ts b/src/services/shims.ts index 6d313b695ce67..af0f424a736ff 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -19,7 +19,7 @@ let debugObjectHost: { CollectGarbage(): void } = (function (this: any) { // esl })(); // We need to use 'null' to interface with the managed side. -/* eslint-disable no-in-operator */ +/* eslint-disable local/no-in-operator */ /* @internal */ namespace ts { @@ -1357,4 +1357,4 @@ namespace ts { } } -/* eslint-enable no-in-operator */ +/* eslint-enable local/no-in-operator */ diff --git a/src/services/signatureHelp.ts b/src/services/signatureHelp.ts index eefc1c44e9c51..569ec1a677813 100644 --- a/src/services/signatureHelp.ts +++ b/src/services/signatureHelp.ts @@ -407,11 +407,11 @@ namespace ts.SignatureHelp { // not enough to put us in the substitution expression; we should consider ourselves part of // the *next* span's expression by offsetting the index (argIndex = (spanIndex + 1) + 1). // - /* eslint-disable no-double-space */ + /* eslint-disable local/no-double-space */ // Example: f `# abcd $#{# 1 + 1# }# efghi ${ #"#hello"# } # ` // ^ ^ ^ ^ ^ ^ ^ ^ ^ // Case: 1 1 3 2 1 3 2 2 1 - /* eslint-enable no-double-space */ + /* eslint-enable local/no-double-space */ Debug.assert(position >= node.getStart(), "Assumed 'position' could not occur before node."); if (isTemplateLiteralToken(node)) { if (isInsideTemplateLiteral(node, position, sourceFile)) { diff --git a/src/testRunner/parallel/host.ts b/src/testRunner/parallel/host.ts index 819325bc85cf3..d9c49e7ca21bf 100644 --- a/src/testRunner/parallel/host.ts +++ b/src/testRunner/parallel/host.ts @@ -45,7 +45,7 @@ namespace Harness.Parallel.Host { constructor(info: ErrorInfo | TestInfo) { super(info.name[info.name.length - 1]); this.info = info; - this.state = "error" in info ? "failed" : "passed"; // eslint-disable-line no-in-operator + this.state = "error" in info ? "failed" : "passed"; // eslint-disable-line local/no-in-operator this.pending = false; } } @@ -512,7 +512,7 @@ namespace Harness.Parallel.Host { function replayTest(runner: Mocha.Runner, test: RemoteTest) { runner.emit("test", test); if (test.isFailed()) { - runner.emit("fail", test, "error" in test.info ? rebuildError(test.info) : new Error("Unknown error")); // eslint-disable-line no-in-operator + runner.emit("fail", test, "error" in test.info ? rebuildError(test.info) : new Error("Unknown error")); // eslint-disable-line local/no-in-operator } else { runner.emit("pass", test); diff --git a/src/testRunner/unittests/services/textChanges.ts b/src/testRunner/unittests/services/textChanges.ts index 8db2d8d517178..2feaebd530288 100644 --- a/src/testRunner/unittests/services/textChanges.ts +++ b/src/testRunner/unittests/services/textChanges.ts @@ -550,7 +550,7 @@ import { x } from "bar"`; runSingleFileTest("insertNodeInListAfter12", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => { - // eslint-disable-next-line boolean-trivia + // eslint-disable-next-line local/boolean-trivia changeTracker.insertNodeInListAfter(sourceFile, findChild("x", sourceFile), factory.createImportSpecifier(/*isTypeOnly*/ false, undefined, factory.createIdentifier("a"))); }); } @@ -560,7 +560,7 @@ import { x // this is x } from "bar"`; runSingleFileTest("insertNodeInListAfter13", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => { - // eslint-disable-next-line boolean-trivia + // eslint-disable-next-line local/boolean-trivia changeTracker.insertNodeInListAfter(sourceFile, findChild("x", sourceFile), factory.createImportSpecifier(/*isTypeOnly*/ false, undefined, factory.createIdentifier("a"))); }); } @@ -591,7 +591,7 @@ import { x } from "bar"`; runSingleFileTest("insertNodeInListAfter16", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => { - // eslint-disable-next-line boolean-trivia + // eslint-disable-next-line local/boolean-trivia changeTracker.insertNodeInListAfter(sourceFile, findChild("x", sourceFile), factory.createImportSpecifier(/*isTypeOnly*/ false, undefined, factory.createIdentifier("a"))); }); } @@ -602,7 +602,7 @@ import { x // this is x } from "bar"`; runSingleFileTest("insertNodeInListAfter17", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => { - // eslint-disable-next-line boolean-trivia + // eslint-disable-next-line local/boolean-trivia changeTracker.insertNodeInListAfter(sourceFile, findChild("x", sourceFile), factory.createImportSpecifier(/*isTypeOnly*/ false, undefined, factory.createIdentifier("a"))); }); } @@ -612,14 +612,14 @@ import { x0, x } from "bar"`; runSingleFileTest("insertNodeInListAfter18", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => { - // eslint-disable-next-line boolean-trivia + // eslint-disable-next-line local/boolean-trivia changeTracker.insertNodeInListAfter(sourceFile, findChild("x", sourceFile), factory.createImportSpecifier(/*isTypeOnly*/ false, undefined, factory.createIdentifier("a"))); }); } { const runTest = (name: string, text: string) => runSingleFileTest(name, /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => { for (const specifier of ["x3", "x4", "x5"]) { - // eslint-disable-next-line boolean-trivia + // eslint-disable-next-line local/boolean-trivia changeTracker.insertNodeInListAfter(sourceFile, findChild("x2", sourceFile), factory.createImportSpecifier(/*isTypeOnly*/ false, undefined, factory.createIdentifier(specifier))); } }); @@ -639,7 +639,7 @@ class A { const newNodes = []; for (let i = 0; i < 11 /*error doesn't occur with fewer nodes*/; ++i) { newNodes.push( - // eslint-disable-next-line boolean-trivia + // eslint-disable-next-line local/boolean-trivia factory.createPropertyDeclaration(undefined, i + "", undefined, undefined, undefined)); } const insertAfter = findChild("x", sourceFile); @@ -655,7 +655,7 @@ class A { } `; runSingleFileTest("insertNodeAfterInClass1", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => { - // eslint-disable-next-line boolean-trivia + // eslint-disable-next-line local/boolean-trivia changeTracker.insertNodeAfter(sourceFile, findChild("x", sourceFile), factory.createPropertyDeclaration(undefined, "a", undefined, factory.createKeywordTypeNode(SyntaxKind.BooleanKeyword), undefined)); }); } @@ -666,7 +666,7 @@ class A { } `; runSingleFileTest("insertNodeAfterInClass2", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => { - // eslint-disable-next-line boolean-trivia + // eslint-disable-next-line local/boolean-trivia changeTracker.insertNodeAfter(sourceFile, findChild("x", sourceFile), factory.createPropertyDeclaration(undefined, "a", undefined, factory.createKeywordTypeNode(SyntaxKind.BooleanKeyword), undefined)); }); } diff --git a/src/testRunner/unittests/tsserver/helpers.ts b/src/testRunner/unittests/tsserver/helpers.ts index bd99f8c79c4a6..f87355f7491f9 100644 --- a/src/testRunner/unittests/tsserver/helpers.ts +++ b/src/testRunner/unittests/tsserver/helpers.ts @@ -695,7 +695,7 @@ namespace ts.projectSystem { export function openFilesForSession(files: readonly (File | { readonly file: File | string, readonly projectRootPath: string, content?: string })[], session: server.Session): void { for (const file of files) { session.executeCommand(makeSessionRequest(CommandNames.Open, - "projectRootPath" in file ? { file: typeof file.file === "string" ? file.file : file.file.path, projectRootPath: file.projectRootPath } : { file: file.path })); // eslint-disable-line no-in-operator + "projectRootPath" in file ? { file: typeof file.file === "string" ? file.file : file.file.path, projectRootPath: file.projectRootPath } : { file: file.path })); // eslint-disable-line local/no-in-operator } } diff --git a/src/testRunner/unittests/tsserver/projectReferences.ts b/src/testRunner/unittests/tsserver/projectReferences.ts index 1605fe2311308..d5f2cf6339c74 100644 --- a/src/testRunner/unittests/tsserver/projectReferences.ts +++ b/src/testRunner/unittests/tsserver/projectReferences.ts @@ -1560,7 +1560,7 @@ const b: B = new B();` }); } - /* eslint-disable boolean-trivia */ + /* eslint-disable local/boolean-trivia */ // Pre-loaded = A file from project B is already open when FAR is invoked // dRPL = Project A has disableReferencedProjectLoad @@ -1587,7 +1587,7 @@ const b: B = new B();` baselineDisableReferencedProjectLoad(false, false, false, true); // Loaded | Via redirect | index.ts, helper.ts | baselineDisableReferencedProjectLoad(false, false, false, false); // Loaded | Via redirect | index.ts, helper.ts | - /* eslint-enable boolean-trivia */ + /* eslint-enable local/boolean-trivia */ }); }); } diff --git a/src/testRunner/unittests/tsserver/webServer.ts b/src/testRunner/unittests/tsserver/webServer.ts index d9f09eb4d4b2d..ab78d26308af2 100644 --- a/src/testRunner/unittests/tsserver/webServer.ts +++ b/src/testRunner/unittests/tsserver/webServer.ts @@ -1,4 +1,4 @@ -/* eslint-disable boolean-trivia */ +/* eslint-disable local/boolean-trivia */ namespace ts.projectSystem { describe("unittests:: tsserver:: webServer", () => { class TestWorkerSession extends server.WorkerSession { From 4605d89064e6a43bb156c1885e5ae7760aa7598d Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 22 Aug 2022 17:30:44 -0700 Subject: [PATCH 14/16] Use a mapped type to enforce type-safety on `forEachChild`. (#50409) --- src/compiler/parser.ts | 3 +- src/compiler/types.ts | 52 ++++++++++++++++++++++++++++++++++- src/compiler/visitorPublic.ts | 2 +- 3 files changed, 54 insertions(+), 3 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 1b82ae4d9a335..93939b6f4f2d1 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -96,7 +96,8 @@ namespace ts { } type ForEachChildFunction = (node: TNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) => T | undefined; - const forEachChildTable = { + type ForEachChildTable = { [TNode in ForEachChildNodes as TNode["kind"]]: ForEachChildFunction }; + const forEachChildTable: ForEachChildTable = { [SyntaxKind.QualifiedName]: function forEachChildInQualifiedName(node: QualifiedName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 45b66261eb46e..461a750028356 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -885,9 +885,59 @@ namespace ts { /* @internal */ jsDocCache?: readonly JSDocTag[]; // Cache for getJSDocTags } + // Ideally, `ForEachChildNodes` and `VisitEachChildNodes` would not differ. + // However, `forEachChild` currently processes JSDoc comment syntax and missing declarations more thoroughly. + // On the other hand, `visitEachChild` actually processes `Identifier`s (which really *shouldn't* have children, + // but are constructed as if they could for faked-up `QualifiedName`s in the language service.) + /* @internal */ - export type HasChildren = + export type ForEachChildNodes = + | HasChildren + | MissingDeclaration + | JSDocTypeExpression + | JSDocNonNullableType + | JSDocNullableType + | JSDocOptionalType + | JSDocVariadicType + | JSDocFunctionType + | JSDoc + | JSDocSeeTag + | JSDocNameReference + | JSDocMemberName + | JSDocParameterTag + | JSDocPropertyTag + | JSDocAuthorTag + | JSDocImplementsTag + | JSDocAugmentsTag + | JSDocTemplateTag + | JSDocTypedefTag + | JSDocCallbackTag + | JSDocReturnTag + | JSDocTypeTag + | JSDocThisTag + | JSDocEnumTag + | JSDocSignature + | JSDocLink + | JSDocLinkCode + | JSDocLinkPlain + | JSDocTypeLiteral + | JSDocUnknownTag + | JSDocClassTag + | JSDocPublicTag + | JSDocPrivateTag + | JSDocProtectedTag + | JSDocReadonlyTag + | JSDocDeprecatedTag + ; + + /* @internal */ + export type VisitEachChildNodes = + | HasChildren | Identifier + ; + + /* @internal */ + export type HasChildren = | QualifiedName | ComputedPropertyName | TypeParameterDeclaration diff --git a/src/compiler/visitorPublic.ts b/src/compiler/visitorPublic.ts index 2541b488bfd50..29a112b062294 100644 --- a/src/compiler/visitorPublic.ts +++ b/src/compiler/visitorPublic.ts @@ -403,7 +403,7 @@ namespace ts { // } // // This is then used as the expected type for `visitEachChildTable`. - type VisitEachChildTable = { [TNode in HasChildren as TNode["kind"]]: VisitEachChildFunction }; + type VisitEachChildTable = { [TNode in VisitEachChildNodes as TNode["kind"]]: VisitEachChildFunction }; // NOTE: Before you can add a new method to `visitEachChildTable`, you must first ensure the `Node` subtype you // wish to add is defined in the `HasChildren` union in types.ts. From 12c32553e45e719b990e5fa8e8bb1b8689269a59 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 22 Aug 2022 17:42:29 -0700 Subject: [PATCH 15/16] Split CI linting/playwright out into separate jobs (#50406) --- .github/workflows/ci.yml | 33 ++++++++++++++++++++++++++------- 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e870951c587cb..91f44f272a645 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -11,7 +11,7 @@ on: - release-* jobs: - build: + test: runs-on: ubuntu-latest strategy: @@ -24,8 +24,6 @@ jobs: steps: - uses: actions/checkout@v3 - with: - fetch-depth: 5 - name: Use node version ${{ matrix.node-version }} uses: actions/setup-node@v3 with: @@ -33,18 +31,39 @@ jobs: check-latest: true - run: npm ci - # Re: https://github.com/actions/setup-node/pull/125 - - name: Register Problem Matcher for TSC - run: echo "##[add-matcher].github/tsc.json" - - name: Tests run: npm test -- --no-lint + lint: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-node@v3 + with: + node-version: "*" + check-latest: true + - run: npm ci + - name: Linter run: npm run lint:ci + browser-integration: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-node@v3 + with: + node-version: "*" + check-latest: true + - run: npm ci + - name: Adding playwright run: npm install --no-save --no-package-lock playwright + - name: Build local + run: gulp local + - name: Validate the browser can import TypeScript run: gulp test-browser-integration From f88117dd2475c981f4a6edd8f28e79413aa85e74 Mon Sep 17 00:00:00 2001 From: TypeScript Bot Date: Tue, 23 Aug 2022 06:14:21 +0000 Subject: [PATCH 16/16] Update package-lock.json --- package-lock.json | 180 +++++++++++++++++++++++----------------------- 1 file changed, 90 insertions(+), 90 deletions(-) diff --git a/package-lock.json b/package-lock.json index 063da0c10de9d..baaeb3f1d295f 100644 --- a/package-lock.json +++ b/package-lock.json @@ -598,9 +598,9 @@ "dev": true }, "node_modules/@types/node": { - "version": "18.7.9", - "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.9.tgz", - "integrity": "sha512-0N5Y1XAdcl865nDdjbO0m3T6FdmQ4ijE89/urOHLREyTXbpMWbSafx9y7XIsgWGtwUP2iYTinLyyW3FatAxBLQ==", + "version": "18.7.11", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.11.tgz", + "integrity": "sha512-KZhFpSLlmK/sdocfSAjqPETTMd0ug6HIMIAwkwUpU79olnZdQtMxpQP+G1wDzCH7na+FltSIhbaZuKdwZ8RDrw==", "dev": true }, "node_modules/@types/node-fetch": { @@ -670,14 +670,14 @@ } }, "node_modules/@typescript-eslint/eslint-plugin": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.33.1.tgz", - "integrity": "sha512-S1iZIxrTvKkU3+m63YUOxYPKaP+yWDQrdhxTglVDVEVBf+aCSw85+BmJnyUaQQsk5TXFG/LpBu9fa+LrAQ91fQ==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.34.0.tgz", + "integrity": "sha512-eRfPPcasO39iwjlUAMtjeueRGuIrW3TQ9WseIDl7i5UWuFbf83yYaU7YPs4j8+4CxUMIsj1k+4kV+E+G+6ypDQ==", "dev": true, "dependencies": { - "@typescript-eslint/scope-manager": "5.33.1", - "@typescript-eslint/type-utils": "5.33.1", - "@typescript-eslint/utils": "5.33.1", + "@typescript-eslint/scope-manager": "5.34.0", + "@typescript-eslint/type-utils": "5.34.0", + "@typescript-eslint/utils": "5.34.0", "debug": "^4.3.4", "functional-red-black-tree": "^1.0.1", "ignore": "^5.2.0", @@ -703,14 +703,14 @@ } }, "node_modules/@typescript-eslint/parser": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.33.1.tgz", - "integrity": "sha512-IgLLtW7FOzoDlmaMoXdxG8HOCByTBXrB1V2ZQYSEV1ggMmJfAkMWTwUjjzagS6OkfpySyhKFkBw7A9jYmcHpZA==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.34.0.tgz", + "integrity": "sha512-SZ3NEnK4usd2CXkoV3jPa/vo1mWX1fqRyIVUQZR4As1vyp4fneknBNJj+OFtV8WAVgGf+rOHMSqQbs2Qn3nFZQ==", "dev": true, "dependencies": { - "@typescript-eslint/scope-manager": "5.33.1", - "@typescript-eslint/types": "5.33.1", - "@typescript-eslint/typescript-estree": "5.33.1", + "@typescript-eslint/scope-manager": "5.34.0", + "@typescript-eslint/types": "5.34.0", + "@typescript-eslint/typescript-estree": "5.34.0", "debug": "^4.3.4" }, "engines": { @@ -730,13 +730,13 @@ } }, "node_modules/@typescript-eslint/scope-manager": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.33.1.tgz", - "integrity": "sha512-8ibcZSqy4c5m69QpzJn8XQq9NnqAToC8OdH/W6IXPXv83vRyEDPYLdjAlUx8h/rbusq6MkW4YdQzURGOqsn3CA==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.34.0.tgz", + "integrity": "sha512-HNvASMQlah5RsBW6L6c7IJ0vsm+8Sope/wu5sEAf7joJYWNb1LDbJipzmdhdUOnfrDFE6LR1j57x1EYVxrY4ow==", "dev": true, "dependencies": { - "@typescript-eslint/types": "5.33.1", - "@typescript-eslint/visitor-keys": "5.33.1" + "@typescript-eslint/types": "5.34.0", + "@typescript-eslint/visitor-keys": "5.34.0" }, "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" @@ -747,12 +747,12 @@ } }, "node_modules/@typescript-eslint/type-utils": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.33.1.tgz", - "integrity": "sha512-X3pGsJsD8OiqhNa5fim41YtlnyiWMF/eKsEZGsHID2HcDqeSC5yr/uLOeph8rNF2/utwuI0IQoAK3fpoxcLl2g==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.34.0.tgz", + "integrity": "sha512-Pxlno9bjsQ7hs1pdWRUv9aJijGYPYsHpwMeCQ/Inavhym3/XaKt1ZKAA8FIw4odTBfowBdZJDMxf2aavyMDkLg==", "dev": true, "dependencies": { - "@typescript-eslint/utils": "5.33.1", + "@typescript-eslint/utils": "5.34.0", "debug": "^4.3.4", "tsutils": "^3.21.0" }, @@ -773,9 +773,9 @@ } }, "node_modules/@typescript-eslint/types": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.33.1.tgz", - "integrity": "sha512-7K6MoQPQh6WVEkMrMW5QOA5FO+BOwzHSNd0j3+BlBwd6vtzfZceJ8xJ7Um2XDi/O3umS8/qDX6jdy2i7CijkwQ==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.34.0.tgz", + "integrity": "sha512-49fm3xbbUPuzBIOcy2CDpYWqy/X7VBkxVN+DC21e0zIm3+61Z0NZi6J9mqPmSW1BDVk9FIOvuCFyUPjXz93sjA==", "dev": true, "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" @@ -786,13 +786,13 @@ } }, "node_modules/@typescript-eslint/typescript-estree": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.33.1.tgz", - "integrity": "sha512-JOAzJ4pJ+tHzA2pgsWQi4804XisPHOtbvwUyqsuuq8+y5B5GMZs7lI1xDWs6V2d7gE/Ez5bTGojSK12+IIPtXA==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.34.0.tgz", + "integrity": "sha512-mXHAqapJJDVzxauEkfJI96j3D10sd567LlqroyCeJaHnu42sDbjxotGb3XFtGPYKPD9IyLjhsoULML1oI3M86A==", "dev": true, "dependencies": { - "@typescript-eslint/types": "5.33.1", - "@typescript-eslint/visitor-keys": "5.33.1", + "@typescript-eslint/types": "5.34.0", + "@typescript-eslint/visitor-keys": "5.34.0", "debug": "^4.3.4", "globby": "^11.1.0", "is-glob": "^4.0.3", @@ -813,15 +813,15 @@ } }, "node_modules/@typescript-eslint/utils": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.33.1.tgz", - "integrity": "sha512-uphZjkMaZ4fE8CR4dU7BquOV6u0doeQAr8n6cQenl/poMaIyJtBu8eys5uk6u5HiDH01Mj5lzbJ5SfeDz7oqMQ==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.34.0.tgz", + "integrity": "sha512-kWRYybU4Rn++7lm9yu8pbuydRyQsHRoBDIo11k7eqBWTldN4xUdVUMCsHBiE7aoEkFzrUEaZy3iH477vr4xHAQ==", "dev": true, "dependencies": { "@types/json-schema": "^7.0.9", - "@typescript-eslint/scope-manager": "5.33.1", - "@typescript-eslint/types": "5.33.1", - "@typescript-eslint/typescript-estree": "5.33.1", + "@typescript-eslint/scope-manager": "5.34.0", + "@typescript-eslint/types": "5.34.0", + "@typescript-eslint/typescript-estree": "5.34.0", "eslint-scope": "^5.1.1", "eslint-utils": "^3.0.0" }, @@ -837,12 +837,12 @@ } }, "node_modules/@typescript-eslint/visitor-keys": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.33.1.tgz", - "integrity": "sha512-nwIxOK8Z2MPWltLKMLOEZwmfBZReqUdbEoHQXeCpa+sRVARe5twpJGHCB4dk9903Yaf0nMAlGbQfaAH92F60eg==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.34.0.tgz", + "integrity": "sha512-O1moYjOSrab0a2fUvFpsJe0QHtvTC+cR+ovYpgKrAVXzqQyc74mv76TgY6z+aEtjQE2vgZux3CQVtGryqdcOAw==", "dev": true, "dependencies": { - "@typescript-eslint/types": "5.33.1", + "@typescript-eslint/types": "5.34.0", "eslint-visitor-keys": "^3.3.0" }, "engines": { @@ -7438,9 +7438,9 @@ } }, "node_modules/spdx-license-ids": { - "version": "3.0.11", - "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.11.tgz", - "integrity": "sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g==", + "version": "3.0.12", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.12.tgz", + "integrity": "sha512-rr+VVSXtRhO4OHbXUiAF7xW3Bo9DuuF6C5jH+q/x15j2jniycgKbxU09Hr0WqlSLUs4i4ltHGXqTe7VHclYWyA==", "dev": true }, "node_modules/split-string": { @@ -9035,9 +9035,9 @@ "dev": true }, "@types/node": { - "version": "18.7.9", - "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.9.tgz", - "integrity": "sha512-0N5Y1XAdcl865nDdjbO0m3T6FdmQ4ijE89/urOHLREyTXbpMWbSafx9y7XIsgWGtwUP2iYTinLyyW3FatAxBLQ==", + "version": "18.7.11", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.11.tgz", + "integrity": "sha512-KZhFpSLlmK/sdocfSAjqPETTMd0ug6HIMIAwkwUpU79olnZdQtMxpQP+G1wDzCH7na+FltSIhbaZuKdwZ8RDrw==", "dev": true }, "@types/node-fetch": { @@ -9107,14 +9107,14 @@ } }, "@typescript-eslint/eslint-plugin": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.33.1.tgz", - "integrity": "sha512-S1iZIxrTvKkU3+m63YUOxYPKaP+yWDQrdhxTglVDVEVBf+aCSw85+BmJnyUaQQsk5TXFG/LpBu9fa+LrAQ91fQ==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.34.0.tgz", + "integrity": "sha512-eRfPPcasO39iwjlUAMtjeueRGuIrW3TQ9WseIDl7i5UWuFbf83yYaU7YPs4j8+4CxUMIsj1k+4kV+E+G+6ypDQ==", "dev": true, "requires": { - "@typescript-eslint/scope-manager": "5.33.1", - "@typescript-eslint/type-utils": "5.33.1", - "@typescript-eslint/utils": "5.33.1", + "@typescript-eslint/scope-manager": "5.34.0", + "@typescript-eslint/type-utils": "5.34.0", + "@typescript-eslint/utils": "5.34.0", "debug": "^4.3.4", "functional-red-black-tree": "^1.0.1", "ignore": "^5.2.0", @@ -9124,52 +9124,52 @@ } }, "@typescript-eslint/parser": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.33.1.tgz", - "integrity": "sha512-IgLLtW7FOzoDlmaMoXdxG8HOCByTBXrB1V2ZQYSEV1ggMmJfAkMWTwUjjzagS6OkfpySyhKFkBw7A9jYmcHpZA==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.34.0.tgz", + "integrity": "sha512-SZ3NEnK4usd2CXkoV3jPa/vo1mWX1fqRyIVUQZR4As1vyp4fneknBNJj+OFtV8WAVgGf+rOHMSqQbs2Qn3nFZQ==", "dev": true, "requires": { - "@typescript-eslint/scope-manager": "5.33.1", - "@typescript-eslint/types": "5.33.1", - "@typescript-eslint/typescript-estree": "5.33.1", + "@typescript-eslint/scope-manager": "5.34.0", + "@typescript-eslint/types": "5.34.0", + "@typescript-eslint/typescript-estree": "5.34.0", "debug": "^4.3.4" } }, "@typescript-eslint/scope-manager": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.33.1.tgz", - "integrity": "sha512-8ibcZSqy4c5m69QpzJn8XQq9NnqAToC8OdH/W6IXPXv83vRyEDPYLdjAlUx8h/rbusq6MkW4YdQzURGOqsn3CA==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.34.0.tgz", + "integrity": "sha512-HNvASMQlah5RsBW6L6c7IJ0vsm+8Sope/wu5sEAf7joJYWNb1LDbJipzmdhdUOnfrDFE6LR1j57x1EYVxrY4ow==", "dev": true, "requires": { - "@typescript-eslint/types": "5.33.1", - "@typescript-eslint/visitor-keys": "5.33.1" + "@typescript-eslint/types": "5.34.0", + "@typescript-eslint/visitor-keys": "5.34.0" } }, "@typescript-eslint/type-utils": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.33.1.tgz", - "integrity": "sha512-X3pGsJsD8OiqhNa5fim41YtlnyiWMF/eKsEZGsHID2HcDqeSC5yr/uLOeph8rNF2/utwuI0IQoAK3fpoxcLl2g==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.34.0.tgz", + "integrity": "sha512-Pxlno9bjsQ7hs1pdWRUv9aJijGYPYsHpwMeCQ/Inavhym3/XaKt1ZKAA8FIw4odTBfowBdZJDMxf2aavyMDkLg==", "dev": true, "requires": { - "@typescript-eslint/utils": "5.33.1", + "@typescript-eslint/utils": "5.34.0", "debug": "^4.3.4", "tsutils": "^3.21.0" } }, "@typescript-eslint/types": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.33.1.tgz", - "integrity": "sha512-7K6MoQPQh6WVEkMrMW5QOA5FO+BOwzHSNd0j3+BlBwd6vtzfZceJ8xJ7Um2XDi/O3umS8/qDX6jdy2i7CijkwQ==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.34.0.tgz", + "integrity": "sha512-49fm3xbbUPuzBIOcy2CDpYWqy/X7VBkxVN+DC21e0zIm3+61Z0NZi6J9mqPmSW1BDVk9FIOvuCFyUPjXz93sjA==", "dev": true }, "@typescript-eslint/typescript-estree": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.33.1.tgz", - "integrity": "sha512-JOAzJ4pJ+tHzA2pgsWQi4804XisPHOtbvwUyqsuuq8+y5B5GMZs7lI1xDWs6V2d7gE/Ez5bTGojSK12+IIPtXA==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.34.0.tgz", + "integrity": "sha512-mXHAqapJJDVzxauEkfJI96j3D10sd567LlqroyCeJaHnu42sDbjxotGb3XFtGPYKPD9IyLjhsoULML1oI3M86A==", "dev": true, "requires": { - "@typescript-eslint/types": "5.33.1", - "@typescript-eslint/visitor-keys": "5.33.1", + "@typescript-eslint/types": "5.34.0", + "@typescript-eslint/visitor-keys": "5.34.0", "debug": "^4.3.4", "globby": "^11.1.0", "is-glob": "^4.0.3", @@ -9178,26 +9178,26 @@ } }, "@typescript-eslint/utils": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.33.1.tgz", - "integrity": "sha512-uphZjkMaZ4fE8CR4dU7BquOV6u0doeQAr8n6cQenl/poMaIyJtBu8eys5uk6u5HiDH01Mj5lzbJ5SfeDz7oqMQ==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.34.0.tgz", + "integrity": "sha512-kWRYybU4Rn++7lm9yu8pbuydRyQsHRoBDIo11k7eqBWTldN4xUdVUMCsHBiE7aoEkFzrUEaZy3iH477vr4xHAQ==", "dev": true, "requires": { "@types/json-schema": "^7.0.9", - "@typescript-eslint/scope-manager": "5.33.1", - "@typescript-eslint/types": "5.33.1", - "@typescript-eslint/typescript-estree": "5.33.1", + "@typescript-eslint/scope-manager": "5.34.0", + "@typescript-eslint/types": "5.34.0", + "@typescript-eslint/typescript-estree": "5.34.0", "eslint-scope": "^5.1.1", "eslint-utils": "^3.0.0" } }, "@typescript-eslint/visitor-keys": { - "version": "5.33.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.33.1.tgz", - "integrity": "sha512-nwIxOK8Z2MPWltLKMLOEZwmfBZReqUdbEoHQXeCpa+sRVARe5twpJGHCB4dk9903Yaf0nMAlGbQfaAH92F60eg==", + "version": "5.34.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.34.0.tgz", + "integrity": "sha512-O1moYjOSrab0a2fUvFpsJe0QHtvTC+cR+ovYpgKrAVXzqQyc74mv76TgY6z+aEtjQE2vgZux3CQVtGryqdcOAw==", "dev": true, "requires": { - "@typescript-eslint/types": "5.33.1", + "@typescript-eslint/types": "5.34.0", "eslint-visitor-keys": "^3.3.0" } }, @@ -14356,9 +14356,9 @@ } }, "spdx-license-ids": { - "version": "3.0.11", - "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.11.tgz", - "integrity": "sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g==", + "version": "3.0.12", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.12.tgz", + "integrity": "sha512-rr+VVSXtRhO4OHbXUiAF7xW3Bo9DuuF6C5jH+q/x15j2jniycgKbxU09Hr0WqlSLUs4i4ltHGXqTe7VHclYWyA==", "dev": true }, "split-string": {