From 79856644b4d476d50013eafee949d1a508b86104 Mon Sep 17 00:00:00 2001 From: Alan Agius Date: Wed, 17 Mar 2021 18:50:03 +0100 Subject: [PATCH] feat(@angular/cli): support TypeScript 4.2 BREAKING CHANGE Drop support for TypeScript versions prior to 4.2.3 --- package.json | 2 +- .../angular_devkit/build_angular/package.json | 2 +- .../build_optimizer/package.json | 2 +- .../core/src/workspace/json/utilities.ts | 28 +- packages/ngtools/webpack/package.json | 4 +- .../Microsoft/TypeScript/BUILD.bazel | 4 +- .../Microsoft/TypeScript/lib/typescript.d.ts | 224 +- .../Microsoft/TypeScript/lib/typescript.js | 8110 +++++++++++------ .../angular/utility/latest-versions.ts | 4 +- .../schematics/schematic/files/package.json | 2 +- .../e2e/setup/500-create-project.ts | 9 + tests/legacy-cli/e2e/utils/project.ts | 22 - yarn.lock | 10 +- 13 files changed, 5483 insertions(+), 2940 deletions(-) diff --git a/package.json b/package.json index 5b8364c2a2b2..4b71f45f92f8 100644 --- a/package.json +++ b/package.json @@ -223,7 +223,7 @@ "tslint": "^6.1.3", "tslint-no-circular-imports": "^0.7.0", "tslint-sonarts": "1.9.0", - "typescript": "4.1.5", + "typescript": "4.2.3", "verdaccio": "4.12.0", "verdaccio-auth-memory": "^9.7.2", "webpack": "4.44.2", diff --git a/packages/angular_devkit/build_angular/package.json b/packages/angular_devkit/build_angular/package.json index 2d0b3469257f..8c57b2036628 100644 --- a/packages/angular_devkit/build_angular/package.json +++ b/packages/angular_devkit/build_angular/package.json @@ -87,7 +87,7 @@ "protractor": "^7.0.0", "tailwindcss": "^2.0.0", "tslint": "^6.1.0", - "typescript": "~4.0.0 || ~4.1.0" + "typescript": "~4.2.3" }, "peerDependenciesMeta": { "@angular/localize": { diff --git a/packages/angular_devkit/build_optimizer/package.json b/packages/angular_devkit/build_optimizer/package.json index 19031a1ddf58..d41aac07e9f9 100644 --- a/packages/angular_devkit/build_optimizer/package.json +++ b/packages/angular_devkit/build_optimizer/package.json @@ -12,7 +12,7 @@ "loader-utils": "2.0.0", "source-map": "0.7.3", "tslib": "2.1.0", - "typescript": "4.1.5", + "typescript": "4.2.3", "webpack-sources": "2.2.0" }, "peerDependencies": { diff --git a/packages/angular_devkit/core/src/workspace/json/utilities.ts b/packages/angular_devkit/core/src/workspace/json/utilities.ts index 151f8202a08f..df25d3bc064b 100644 --- a/packages/angular_devkit/core/src/workspace/json/utilities.ts +++ b/packages/angular_devkit/core/src/workspace/json/utilities.ts @@ -37,9 +37,13 @@ type ChangeReporter = ( current?: JsonValue, ) => void; +// lib.es5 PropertyKey is string | number | symbol which doesn't overlap ProxyHandler PropertyKey which is string | symbol. +// See https://github.com/microsoft/TypeScript/issues/42894 +type ProxyPropertyKey = string | symbol; + function findNode( parent: JsonAstArray | JsonAstObject, - p: PropertyKey, + p: ProxyPropertyKey, ): { node?: JsonAstNode; parent: JsonAstArray | JsonAstKeyValue | JsonAstObject } { if (parent.kind === 'object') { const entry = parent.properties.find(entry => entry.key.value === p); @@ -120,8 +124,8 @@ function create( ast: JsonAstObject | JsonAstArray, path: string, reporter: ChangeReporter, - excluded = new Set(), - included?: Set, + excluded = new Set(), + included?: Set, base?: object, ) { const cache = new Map(); @@ -137,7 +141,7 @@ function create( } return new Proxy(base, { - getOwnPropertyDescriptor(target: {}, p: PropertyKey): PropertyDescriptor | undefined { + getOwnPropertyDescriptor(target: {}, p: ProxyPropertyKey): PropertyDescriptor | undefined { const descriptor = Reflect.getOwnPropertyDescriptor(target, p); if (descriptor || typeof p === 'symbol') { return descriptor; @@ -162,7 +166,7 @@ function create( return undefined; }, - has(target: {}, p: PropertyKey): boolean { + has(target: {}, p: ProxyPropertyKey): boolean { if (Reflect.has(target, p)) { return true; } else if (typeof p === 'symbol' || excluded.has(p)) { @@ -171,7 +175,7 @@ function create( return cache.has(path + '/' + escapeKey(p)) || findNode(ast, p) !== undefined; }, - get(target: {}, p: PropertyKey): unknown { + get(target: {}, p: ProxyPropertyKey): unknown { if (typeof p === 'symbol' || Reflect.has(target, p)) { return Reflect.get(target, p); } else if (excluded.has(p) || (included && !included.has(p))) { @@ -206,7 +210,7 @@ function create( return value; }, - set(target: {}, p: PropertyKey, value: unknown): boolean { + set(target: {}, p: ProxyPropertyKey, value: unknown): boolean { if (value === undefined) { // setting to undefined is equivalent to a delete // tslint:disable-next-line: no-non-null-assertion @@ -242,7 +246,7 @@ function create( return true; }, - deleteProperty(target: {}, p: PropertyKey): boolean { + deleteProperty(target: {}, p: ProxyPropertyKey): boolean { if (typeof p === 'symbol' || Reflect.has(target, p)) { return Reflect.deleteProperty(target, p); } else if (excluded.has(p) || (included && !included.has(p))) { @@ -279,15 +283,15 @@ function create( return true; }, - defineProperty(target: {}, p: PropertyKey, attributes: PropertyDescriptor): boolean { + defineProperty(target: {}, p: ProxyPropertyKey, attributes: PropertyDescriptor): boolean { if (typeof p === 'symbol') { return Reflect.defineProperty(target, p, attributes); } return false; }, - ownKeys(target: {}): PropertyKey[] { - let keys: PropertyKey[]; + ownKeys(target: {}): ProxyPropertyKey[] { + let keys: ProxyPropertyKey[]; if (ast.kind === 'object') { keys = ast.properties .map(entry => entry.key.value) @@ -299,7 +303,7 @@ function create( for (const key of cache.keys()) { const relativeKey = key.substr(path.length + 1); if (relativeKey.length > 0 && !relativeKey.includes('/')) { - keys.push(unescapeKey(relativeKey)); + keys.push(`${unescapeKey(relativeKey)}`); } } diff --git a/packages/ngtools/webpack/package.json b/packages/ngtools/webpack/package.json index b694a6dc5079..6ddfa7366e9b 100644 --- a/packages/ngtools/webpack/package.json +++ b/packages/ngtools/webpack/package.json @@ -27,13 +27,13 @@ }, "peerDependencies": { "@angular/compiler-cli": "^12.0.0-next", - "typescript": "~4.0.0 || ~4.1.0", + "typescript": "~4.2.3", "webpack": "^4.0.0 || ^5.20.0" }, "devDependencies": { "@angular/compiler": "12.0.0-next.4", "@angular/compiler-cli": "12.0.0-next.4", - "typescript": "4.1.5", + "typescript": "4.2.3", "webpack": "5.21.2" } } diff --git a/packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/BUILD.bazel b/packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/BUILD.bazel index d3ac34f851aa..cd36c96e2130 100644 --- a/packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/BUILD.bazel +++ b/packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/BUILD.bazel @@ -1,7 +1,7 @@ load("//tools:defaults.bzl", "ts_library") -# files fetched on 2020-08-24 from -# https://github.com/microsoft/TypeScript/releases/tag/v4.0.2 +# files fetched on 2021-03-17 from +# https://github.com/microsoft/TypeScript/releases/tag/v4.2.3 licenses(["notice"]) # Apache 2.0 ts_library( diff --git a/packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript.d.ts b/packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript.d.ts index 7c6c6301d218..bba168d37e72 100644 --- a/packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript.d.ts +++ b/packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript.d.ts @@ -14,7 +14,7 @@ and limitations under the License. ***************************************************************************** */ declare namespace ts { - const versionMajorMinor = "4.1"; + const versionMajorMinor = "4.2"; /** The version of the TypeScript compiler release */ const version: string; /** @@ -81,7 +81,7 @@ declare namespace ts { value: T; done?: false; } | { - value: never; + value: void; done: true; }; } @@ -1598,6 +1598,7 @@ declare namespace ts { readonly kind: SyntaxKind.ImportEqualsDeclaration; readonly parent: SourceFile | ModuleBlock; readonly name: Identifier; + readonly isTypeOnly: boolean; readonly moduleReference: ModuleReference; } export interface ExternalModuleReference extends Node { @@ -1668,7 +1669,7 @@ declare namespace ts { readonly name: Identifier; } export type ImportOrExportSpecifier = ImportSpecifier | ExportSpecifier; - export type TypeOnlyCompatibleAliasDeclaration = ImportClause | NamespaceImport | ImportOrExportSpecifier; + export type TypeOnlyCompatibleAliasDeclaration = ImportClause | ImportEqualsDeclaration | NamespaceImport | ImportOrExportSpecifier; /** * This is either an `export =` or an `export default` declaration. * Unless `isExportEquals` is set, this node was parsed as an `export default`. @@ -2590,7 +2591,10 @@ declare namespace ts { Optional = 2, Rest = 4, Variadic = 8, - Variable = 12 + Fixed = 3, + Variable = 12, + NonRequired = 14, + NonRest = 11 } export interface TupleType extends GenericType { elementFlags: readonly ElementFlags[]; @@ -2831,6 +2835,7 @@ declare namespace ts { noUnusedLocals?: boolean; noUnusedParameters?: boolean; noImplicitUseStrict?: boolean; + noPropertyAccessFromIndexSignature?: boolean; assumeChangesOnlyAffectDirectDependencies?: boolean; noLib?: boolean; noResolve?: boolean; @@ -2879,6 +2884,8 @@ declare namespace ts { watchDirectory?: WatchDirectoryKind; fallbackPolling?: PollingWatchKind; synchronousWatchDirectory?: boolean; + excludeDirectories?: string[]; + excludeFiles?: string[]; [option: string]: CompilerOptionsValue | undefined; } export interface TypeAcquisition { @@ -2972,10 +2979,6 @@ declare namespace ts { None = 0, Recursive = 1 } - export interface ExpandResult { - fileNames: string[]; - wildcardDirectories: MapLike; - } export interface CreateProgramOptions { rootNames: readonly string[]; options: CompilerOptions; @@ -3228,7 +3231,11 @@ declare namespace ts { updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray | undefined): TypeReferenceNode; createFunctionTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): FunctionTypeNode; updateFunctionTypeNode(node: FunctionTypeNode, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode): FunctionTypeNode; + createConstructorTypeNode(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode; + /** @deprecated */ createConstructorTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode; + updateConstructorTypeNode(node: ConstructorTypeNode, modifiers: readonly Modifier[] | undefined, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode): ConstructorTypeNode; + /** @deprecated */ updateConstructorTypeNode(node: ConstructorTypeNode, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode): ConstructorTypeNode; createTypeQueryNode(exprName: EntityName): TypeQueryNode; updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName): TypeQueryNode; @@ -3406,8 +3413,8 @@ declare namespace ts { updateCaseBlock(node: CaseBlock, clauses: readonly CaseOrDefaultClause[]): CaseBlock; createNamespaceExportDeclaration(name: string | Identifier): NamespaceExportDeclaration; updateNamespaceExportDeclaration(node: NamespaceExportDeclaration, name: Identifier): NamespaceExportDeclaration; - createImportEqualsDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration; - updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration; + createImportEqualsDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration; + updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration; createImportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression): ImportDeclaration; updateImportDeclaration(node: ImportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression): ImportDeclaration; createImportClause(isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause; @@ -3681,8 +3688,8 @@ declare namespace ts { */ export type Visitor = (node: Node) => VisitResult; export interface NodeVisitor { - (nodes: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: NodeArray) => T): T; - (nodes: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: NodeArray) => T): T | undefined; + (nodes: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T; + (nodes: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T | undefined; } export interface NodesVisitor { (nodes: NodeArray, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray; @@ -3862,7 +3869,7 @@ declare namespace ts { readonly includeCompletionsForModuleExports?: boolean; readonly includeAutomaticOptionalChainCompletions?: boolean; readonly includeCompletionsWithInsertText?: boolean; - readonly importModuleSpecifierPreference?: "auto" | "relative" | "non-relative"; + readonly importModuleSpecifierPreference?: "shortest" | "project-relative" | "relative" | "non-relative"; /** Determines whether we import `foo/index.ts` as "foo", "foo/index", or "foo/index.js" */ readonly importModuleSpecifierEnding?: "auto" | "minimal" | "index" | "js"; readonly allowTextChangesInNewFiles?: boolean; @@ -3961,6 +3968,7 @@ declare namespace ts { reScanJsxToken(): JsxTokenSyntaxKind; reScanLessThanToken(): SyntaxKind; reScanQuestionToken(): SyntaxKind; + reScanInvalidIdentifier(): SyntaxKind; scanJsxToken(): JsxTokenSyntaxKind; scanJsDocToken(): JSDocSyntaxKind; scan(): SyntaxKind; @@ -4504,6 +4512,7 @@ declare namespace ts { function isJSDocProtectedTag(node: Node): node is JSDocProtectedTag; function isJSDocReadonlyTag(node: Node): node is JSDocReadonlyTag; function isJSDocDeprecatedTag(node: Node): node is JSDocDeprecatedTag; + function isJSDocSeeTag(node: Node): node is JSDocSeeTag; function isJSDocEnumTag(node: Node): node is JSDocEnumTag; function isJSDocParameterTag(node: Node): node is JSDocParameterTag; function isJSDocReturnTag(node: Node): node is JSDocReturnTag; @@ -4683,7 +4692,7 @@ declare namespace ts { * @param test A callback to execute to verify the Node is valid. * @param lift An optional callback to execute to lift a NodeArray into a valid Node. */ - function visitNode(node: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: NodeArray) => T): T; + function visitNode(node: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T; /** * Visits a Node using the supplied visitor, possibly returning a new Node in its place. * @@ -4692,7 +4701,7 @@ declare namespace ts { * @param test A callback to execute to verify the Node is valid. * @param lift An optional callback to execute to lift a NodeArray into a valid Node. */ - function visitNode(node: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: NodeArray) => T): T | undefined; + function visitNode(node: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T | undefined; /** * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place. * @@ -5530,6 +5539,7 @@ declare namespace ts { getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[] | undefined; findReferences(fileName: string, position: number): ReferencedSymbol[] | undefined; getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): DocumentHighlights[] | undefined; + getFileReferences(fileName: string): ReferenceEntry[]; /** @deprecated */ getOccurrencesAtPosition(fileName: string, position: number): readonly ReferenceEntry[] | undefined; getNavigateToItems(searchValue: string, maxResultCount?: number, fileName?: string, excludeDtsFiles?: boolean): NavigateToItem[]; @@ -5545,7 +5555,7 @@ declare namespace ts { getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions | FormatCodeSettings): TextChange[]; getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[]; getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[]; - getDocCommentTemplateAtPosition(fileName: string, position: number): TextInsertion | undefined; + getDocCommentTemplateAtPosition(fileName: string, position: number, options?: DocCommentTemplateOptions): TextInsertion | undefined; isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean; /** * This will return a defined result if the position is after the `>` of the opening tag, or somewhere in the text, of a JSXElement with no closing tag. @@ -5565,7 +5575,7 @@ declare namespace ts { applyCodeActionCommand(fileName: string, action: CodeActionCommand[]): Promise; /** @deprecated `fileName` will be ignored */ applyCodeActionCommand(fileName: string, action: CodeActionCommand | CodeActionCommand[]): Promise; - getApplicableRefactors(fileName: string, positionOrRange: number | TextRange, preferences: UserPreferences | undefined, triggerReason?: RefactorTriggerReason): ApplicableRefactorInfo[]; + getApplicableRefactors(fileName: string, positionOrRange: number | TextRange, preferences: UserPreferences | undefined, triggerReason?: RefactorTriggerReason, kind?: string): ApplicableRefactorInfo[]; getEditsForRefactor(fileName: string, formatOptions: FormatCodeSettings, positionOrRange: number | TextRange, refactorName: string, actionName: string, preferences: UserPreferences | undefined): RefactorEditInfo | undefined; organizeImports(scope: OrganizeImportsScope, formatOptions: FormatCodeSettings, preferences: UserPreferences | undefined): readonly FileTextChanges[]; getEditsForFileRename(oldFilePath: string, newFilePath: string, formatOptions: FormatCodeSettings, preferences: UserPreferences | undefined): readonly FileTextChanges[]; @@ -5791,6 +5801,10 @@ declare namespace ts { * the current context. */ notApplicableReason?: string; + /** + * The hierarchical dotted name of the refactor action. + */ + kind?: string; } /** * A set of edits to make in response to a refactor action, plus an optional @@ -6006,11 +6020,15 @@ declare namespace ts { interface RenameInfoOptions { readonly allowRenameOfImportPath?: boolean; } + interface DocCommentTemplateOptions { + readonly generateReturnInDocTemplate?: boolean; + } interface SignatureHelpParameter { name: string; documentation: SymbolDisplayPart[]; displayParts: SymbolDisplayPart[]; isOptional: boolean; + isRest?: boolean; } interface SelectionRange { textSpan: TextSpan; @@ -6447,7 +6465,7 @@ declare namespace ts { (text: string, isSingleQuote?: boolean | undefined, hasExtendedUnicodeEscape?: boolean | undefined): StringLiteral; }; /** @deprecated Use `factory.createStringLiteralFromNode` or the factory supplied by your transformation context instead. */ - const createStringLiteralFromNode: (sourceNode: Identifier | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral, isSingleQuote?: boolean | undefined) => StringLiteral; + const createStringLiteralFromNode: (sourceNode: PropertyNameLiteral, isSingleQuote?: boolean | undefined) => StringLiteral; /** @deprecated Use `factory.createRegularExpressionLiteral` or the factory supplied by your transformation context instead. */ const createRegularExpressionLiteral: (text: string) => RegularExpressionLiteral; /** @deprecated Use `factory.createLoopVariable` or the factory supplied by your transformation context instead. */ @@ -6483,19 +6501,19 @@ declare namespace ts { /** @deprecated Use `factory.updateTypeParameterDeclaration` or the factory supplied by your transformation context instead. */ const updateTypeParameterDeclaration: (node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined) => TypeParameterDeclaration; /** @deprecated Use `factory.createParameterDeclaration` or the factory supplied by your transformation context instead. */ - const createParameter: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | Identifier | ObjectBindingPattern | ArrayBindingPattern, questionToken?: QuestionToken | undefined, type?: TypeNode | undefined, initializer?: Expression | undefined) => ParameterDeclaration; + const createParameter: (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 Use `factory.updateParameterDeclaration` or the factory supplied by your transformation context instead. */ - const updateParameter: (node: ParameterDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | Identifier | ObjectBindingPattern | ArrayBindingPattern, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => ParameterDeclaration; + const updateParameter: (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 Use `factory.createDecorator` or the factory supplied by your transformation context instead. */ const createDecorator: (expression: Expression) => Decorator; /** @deprecated Use `factory.updateDecorator` or the factory supplied by your transformation context instead. */ const updateDecorator: (node: Decorator, expression: Expression) => Decorator; /** @deprecated Use `factory.createPropertyDeclaration` or the factory supplied by your transformation context instead. */ - const createProperty: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => PropertyDeclaration; + const createProperty: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => PropertyDeclaration; /** @deprecated Use `factory.updatePropertyDeclaration` or the factory supplied by your transformation context instead. */ - const updateProperty: (node: PropertyDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => PropertyDeclaration; + const updateProperty: (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 Use `factory.createMethodDeclaration` or the factory supplied by your transformation context instead. */ - const createMethod: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) => MethodDeclaration; + const createMethod: (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 Use `factory.updateMethodDeclaration` or the factory supplied by your transformation context instead. */ const updateMethod: (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 Use `factory.createConstructorDeclaration` or the factory supplied by your transformation context instead. */ @@ -6503,11 +6521,11 @@ declare namespace ts { /** @deprecated Use `factory.updateConstructorDeclaration` or the factory supplied by your transformation context instead. */ const updateConstructor: (node: ConstructorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined) => ConstructorDeclaration; /** @deprecated Use `factory.createGetAccessorDeclaration` or the factory supplied by your transformation context instead. */ - const createGetAccessor: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) => GetAccessorDeclaration; + const createGetAccessor: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) => GetAccessorDeclaration; /** @deprecated Use `factory.updateGetAccessorDeclaration` or the factory supplied by your transformation context instead. */ const updateGetAccessor: (node: GetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) => GetAccessorDeclaration; /** @deprecated Use `factory.createSetAccessorDeclaration` or the factory supplied by your transformation context instead. */ - const createSetAccessor: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, parameters: readonly ParameterDeclaration[], body: Block | undefined) => SetAccessorDeclaration; + const createSetAccessor: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined) => SetAccessorDeclaration; /** @deprecated Use `factory.updateSetAccessorDeclaration` or the factory supplied by your transformation context instead. */ const updateSetAccessor: (node: SetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined) => SetAccessorDeclaration; /** @deprecated Use `factory.createCallSignature` or the factory supplied by your transformation context instead. */ @@ -6527,7 +6545,7 @@ declare namespace ts { /** @deprecated Use `factory.updateTypePredicateNode` or the factory supplied by your transformation context instead. */ const updateTypePredicateNodeWithModifier: (node: TypePredicateNode, assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined) => TypePredicateNode; /** @deprecated Use `factory.createTypeReferenceNode` or the factory supplied by your transformation context instead. */ - const createTypeReferenceNode: (typeName: string | Identifier | QualifiedName, typeArguments?: readonly TypeNode[] | undefined) => TypeReferenceNode; + const createTypeReferenceNode: (typeName: string | EntityName, typeArguments?: readonly TypeNode[] | undefined) => TypeReferenceNode; /** @deprecated Use `factory.updateTypeReferenceNode` or the factory supplied by your transformation context instead. */ const updateTypeReferenceNode: (node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray | undefined) => TypeReferenceNode; /** @deprecated Use `factory.createFunctionTypeNode` or the factory supplied by your transformation context instead. */ @@ -6579,9 +6597,9 @@ declare namespace ts { /** @deprecated Use `factory.updateInferTypeNode` or the factory supplied by your transformation context instead. */ const updateInferTypeNode: (node: InferTypeNode, typeParameter: TypeParameterDeclaration) => InferTypeNode; /** @deprecated Use `factory.createImportTypeNode` or the factory supplied by your transformation context instead. */ - const createImportTypeNode: (argument: TypeNode, qualifier?: Identifier | QualifiedName | undefined, typeArguments?: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined) => ImportTypeNode; + const createImportTypeNode: (argument: TypeNode, qualifier?: EntityName | undefined, typeArguments?: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined) => ImportTypeNode; /** @deprecated Use `factory.updateImportTypeNode` or the factory supplied by your transformation context instead. */ - const updateImportTypeNode: (node: ImportTypeNode, argument: TypeNode, qualifier: Identifier | QualifiedName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined) => ImportTypeNode; + const updateImportTypeNode: (node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined) => ImportTypeNode; /** @deprecated Use `factory.createParenthesizedType` or the factory supplied by your transformation context instead. */ const createParenthesizedType: (type: TypeNode) => ParenthesizedTypeNode; /** @deprecated Use `factory.updateParenthesizedType` or the factory supplied by your transformation context instead. */ @@ -6599,9 +6617,9 @@ declare namespace ts { /** @deprecated Use `factory.updateMappedTypeNode` or the factory supplied by your transformation context instead. */ const updateMappedTypeNode: (node: MappedTypeNode, readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined) => MappedTypeNode; /** @deprecated Use `factory.createLiteralTypeNode` or the factory supplied by your transformation context instead. */ - const createLiteralTypeNode: (literal: LiteralExpression | TrueLiteral | FalseLiteral | PrefixUnaryExpression | NullLiteral) => LiteralTypeNode; + const createLiteralTypeNode: (literal: LiteralExpression | BooleanLiteral | PrefixUnaryExpression | NullLiteral) => LiteralTypeNode; /** @deprecated Use `factory.updateLiteralTypeNode` or the factory supplied by your transformation context instead. */ - const updateLiteralTypeNode: (node: LiteralTypeNode, literal: LiteralExpression | TrueLiteral | FalseLiteral | PrefixUnaryExpression | NullLiteral) => LiteralTypeNode; + const updateLiteralTypeNode: (node: LiteralTypeNode, literal: LiteralExpression | BooleanLiteral | PrefixUnaryExpression | NullLiteral) => LiteralTypeNode; /** @deprecated Use `factory.createObjectBindingPattern` or the factory supplied by your transformation context instead. */ const createObjectBindingPattern: (elements: readonly BindingElement[]) => ObjectBindingPattern; /** @deprecated Use `factory.updateObjectBindingPattern` or the factory supplied by your transformation context instead. */ @@ -6611,84 +6629,84 @@ declare namespace ts { /** @deprecated Use `factory.updateArrayBindingPattern` or the factory supplied by your transformation context instead. */ const updateArrayBindingPattern: (node: ArrayBindingPattern, elements: readonly ArrayBindingElement[]) => ArrayBindingPattern; /** @deprecated Use `factory.createBindingElement` or the factory supplied by your transformation context instead. */ - const createBindingElement: (dotDotDotToken: DotDotDotToken | undefined, propertyName: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier | undefined, name: string | Identifier | ObjectBindingPattern | ArrayBindingPattern, initializer?: Expression | undefined) => BindingElement; + const createBindingElement: (dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression | undefined) => BindingElement; /** @deprecated Use `factory.updateBindingElement` or the factory supplied by your transformation context instead. */ - const updateBindingElement: (node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier | undefined, name: BindingName, initializer: Expression | undefined) => BindingElement; - /** @deprecated Use `factory.createArrayLiteral` or the factory supplied by your transformation context instead. */ + const updateBindingElement: (node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined) => BindingElement; + /** @deprecated Use `factory.createArrayLiteralExpression` or the factory supplied by your transformation context instead. */ const createArrayLiteral: (elements?: readonly Expression[] | undefined, multiLine?: boolean | undefined) => ArrayLiteralExpression; - /** @deprecated Use `factory.updateArrayLiteral` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateArrayLiteralExpression` or the factory supplied by your transformation context instead. */ const updateArrayLiteral: (node: ArrayLiteralExpression, elements: readonly Expression[]) => ArrayLiteralExpression; - /** @deprecated Use `factory.createObjectLiteral` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createObjectLiteralExpression` or the factory supplied by your transformation context instead. */ const createObjectLiteral: (properties?: readonly ObjectLiteralElementLike[] | undefined, multiLine?: boolean | undefined) => ObjectLiteralExpression; - /** @deprecated Use `factory.updateObjectLiteral` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateObjectLiteralExpression` or the factory supplied by your transformation context instead. */ const updateObjectLiteral: (node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]) => ObjectLiteralExpression; - /** @deprecated Use `factory.createPropertyAccess` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createPropertyAccessExpression` or the factory supplied by your transformation context instead. */ const createPropertyAccess: (expression: Expression, name: string | Identifier | PrivateIdentifier) => PropertyAccessExpression; - /** @deprecated Use `factory.updatePropertyAccess` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updatePropertyAccessExpression` or the factory supplied by your transformation context instead. */ const updatePropertyAccess: (node: PropertyAccessExpression, expression: Expression, name: Identifier | PrivateIdentifier) => PropertyAccessExpression; /** @deprecated Use `factory.createPropertyAccessChain` or the factory supplied by your transformation context instead. */ const createPropertyAccessChain: (expression: Expression, questionDotToken: QuestionDotToken | undefined, name: string | Identifier | PrivateIdentifier) => PropertyAccessChain; /** @deprecated Use `factory.updatePropertyAccessChain` or the factory supplied by your transformation context instead. */ const updatePropertyAccessChain: (node: PropertyAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, name: Identifier | PrivateIdentifier) => PropertyAccessChain; - /** @deprecated Use `factory.createElementAccess` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createElementAccessExpression` or the factory supplied by your transformation context instead. */ const createElementAccess: (expression: Expression, index: number | Expression) => ElementAccessExpression; - /** @deprecated Use `factory.updateElementAccess` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateElementAccessExpression` or the factory supplied by your transformation context instead. */ const updateElementAccess: (node: ElementAccessExpression, expression: Expression, argumentExpression: Expression) => ElementAccessExpression; /** @deprecated Use `factory.createElementAccessChain` or the factory supplied by your transformation context instead. */ const createElementAccessChain: (expression: Expression, questionDotToken: QuestionDotToken | undefined, index: number | Expression) => ElementAccessChain; /** @deprecated Use `factory.updateElementAccessChain` or the factory supplied by your transformation context instead. */ const updateElementAccessChain: (node: ElementAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, argumentExpression: Expression) => ElementAccessChain; - /** @deprecated Use `factory.createCall` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createCallExpression` or the factory supplied by your transformation context instead. */ const createCall: (expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => CallExpression; - /** @deprecated Use `factory.updateCall` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateCallExpression` or the factory supplied by your transformation context instead. */ const updateCall: (node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]) => CallExpression; /** @deprecated Use `factory.createCallChain` or the factory supplied by your transformation context instead. */ const createCallChain: (expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => CallChain; /** @deprecated Use `factory.updateCallChain` or the factory supplied by your transformation context instead. */ const updateCallChain: (node: CallChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]) => CallChain; - /** @deprecated Use `factory.createNew` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createNewExpression` or the factory supplied by your transformation context instead. */ const createNew: (expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => NewExpression; - /** @deprecated Use `factory.updateNew` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateNewExpression` or the factory supplied by your transformation context instead. */ const updateNew: (node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => NewExpression; /** @deprecated Use `factory.createTypeAssertion` or the factory supplied by your transformation context instead. */ const createTypeAssertion: (type: TypeNode, expression: Expression) => TypeAssertion; /** @deprecated Use `factory.updateTypeAssertion` or the factory supplied by your transformation context instead. */ const updateTypeAssertion: (node: TypeAssertion, type: TypeNode, expression: Expression) => TypeAssertion; - /** @deprecated Use `factory.createParen` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createParenthesizedExpression` or the factory supplied by your transformation context instead. */ const createParen: (expression: Expression) => ParenthesizedExpression; - /** @deprecated Use `factory.updateParen` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateParenthesizedExpression` or the factory supplied by your transformation context instead. */ const updateParen: (node: ParenthesizedExpression, expression: Expression) => ParenthesizedExpression; /** @deprecated Use `factory.createFunctionExpression` or the factory supplied by your transformation context instead. */ const createFunctionExpression: (modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[] | undefined, type: TypeNode | undefined, body: Block) => FunctionExpression; /** @deprecated Use `factory.updateFunctionExpression` or the factory supplied by your transformation context instead. */ const updateFunctionExpression: (node: FunctionExpression, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block) => FunctionExpression; - /** @deprecated Use `factory.createDelete` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createDeleteExpression` or the factory supplied by your transformation context instead. */ const createDelete: (expression: Expression) => DeleteExpression; - /** @deprecated Use `factory.updateDelete` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateDeleteExpression` or the factory supplied by your transformation context instead. */ const updateDelete: (node: DeleteExpression, expression: Expression) => DeleteExpression; - /** @deprecated Use `factory.createTypeOf` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createTypeOfExpression` or the factory supplied by your transformation context instead. */ const createTypeOf: (expression: Expression) => TypeOfExpression; - /** @deprecated Use `factory.updateTypeOf` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateTypeOfExpression` or the factory supplied by your transformation context instead. */ const updateTypeOf: (node: TypeOfExpression, expression: Expression) => TypeOfExpression; - /** @deprecated Use `factory.createVoid` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createVoidExpression` or the factory supplied by your transformation context instead. */ const createVoid: (expression: Expression) => VoidExpression; - /** @deprecated Use `factory.updateVoid` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateVoidExpression` or the factory supplied by your transformation context instead. */ const updateVoid: (node: VoidExpression, expression: Expression) => VoidExpression; - /** @deprecated Use `factory.createAwait` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createAwaitExpression` or the factory supplied by your transformation context instead. */ const createAwait: (expression: Expression) => AwaitExpression; - /** @deprecated Use `factory.updateAwait` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateAwaitExpression` or the factory supplied by your transformation context instead. */ const updateAwait: (node: AwaitExpression, expression: Expression) => AwaitExpression; - /** @deprecated Use `factory.createPrefix` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createPrefixExpression` or the factory supplied by your transformation context instead. */ const createPrefix: (operator: PrefixUnaryOperator, operand: Expression) => PrefixUnaryExpression; - /** @deprecated Use `factory.updatePrefix` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updatePrefixExpression` or the factory supplied by your transformation context instead. */ const updatePrefix: (node: PrefixUnaryExpression, operand: Expression) => PrefixUnaryExpression; - /** @deprecated Use `factory.createPostfix` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createPostfixUnaryExpression` or the factory supplied by your transformation context instead. */ const createPostfix: (operand: Expression, operator: PostfixUnaryOperator) => PostfixUnaryExpression; - /** @deprecated Use `factory.updatePostfix` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updatePostfixUnaryExpression` or the factory supplied by your transformation context instead. */ const updatePostfix: (node: PostfixUnaryExpression, operand: Expression) => PostfixUnaryExpression; - /** @deprecated Use `factory.createBinary` or the factory supplied by your transformation context instead. */ - const createBinary: (left: Expression, operator: SyntaxKind.CommaToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.EqualsEqualsToken | SyntaxKind.ExclamationEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.AsteriskToken | SyntaxKind.AsteriskAsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken | SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken | SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken | SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.QuestionQuestionToken | SyntaxKind.EqualsToken | SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.BarBarEqualsToken | SyntaxKind.AmpersandAmpersandEqualsToken | SyntaxKind.QuestionQuestionEqualsToken | SyntaxKind.CaretEqualsToken | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | BinaryOperatorToken, right: Expression) => BinaryExpression; - /** @deprecated Use `factory.updateConditional` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createBinaryExpression` or the factory supplied by your transformation context instead. */ + const createBinary: (left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression) => BinaryExpression; + /** @deprecated Use `factory.updateConditionalExpression` or the factory supplied by your transformation context instead. */ const updateConditional: (node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression) => ConditionalExpression; /** @deprecated Use `factory.createTemplateExpression` or the factory supplied by your transformation context instead. */ const createTemplateExpression: (head: TemplateHead, templateSpans: readonly TemplateSpan[]) => TemplateExpression; @@ -6714,11 +6732,11 @@ declare namespace ts { (text: string, rawText?: string | undefined): NoSubstitutionTemplateLiteral; (text: string | undefined, rawText: string): NoSubstitutionTemplateLiteral; }; - /** @deprecated Use `factory.updateYield` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateYieldExpression` or the factory supplied by your transformation context instead. */ const updateYield: (node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined) => YieldExpression; - /** @deprecated Use `factory.createSpread` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createSpreadExpression` or the factory supplied by your transformation context instead. */ const createSpread: (expression: Expression) => SpreadElement; - /** @deprecated Use `factory.updateSpread` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateSpreadExpression` or the factory supplied by your transformation context instead. */ const updateSpread: (node: SpreadElement, expression: Expression) => SpreadElement; /** @deprecated Use `factory.createOmittedExpression` or the factory supplied by your transformation context instead. */ const createOmittedExpression: () => OmittedExpression; @@ -6762,61 +6780,61 @@ declare namespace ts { const createStatement: (expression: Expression) => ExpressionStatement; /** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */ const updateStatement: (node: ExpressionStatement, expression: Expression) => ExpressionStatement; - /** @deprecated Use `factory.createIf` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createIfStatement` or the factory supplied by your transformation context instead. */ const createIf: (expression: Expression, thenStatement: Statement, elseStatement?: Statement | undefined) => IfStatement; - /** @deprecated Use `factory.updateIf` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateIfStatement` or the factory supplied by your transformation context instead. */ const updateIf: (node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined) => IfStatement; - /** @deprecated Use `factory.createDo` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createDoStatement` or the factory supplied by your transformation context instead. */ const createDo: (statement: Statement, expression: Expression) => DoStatement; - /** @deprecated Use `factory.updateDo` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateDoStatement` or the factory supplied by your transformation context instead. */ const updateDo: (node: DoStatement, statement: Statement, expression: Expression) => DoStatement; - /** @deprecated Use `factory.createWhile` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createWhileStatement` or the factory supplied by your transformation context instead. */ const createWhile: (expression: Expression, statement: Statement) => WhileStatement; - /** @deprecated Use `factory.updateWhile` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateWhileStatement` or the factory supplied by your transformation context instead. */ const updateWhile: (node: WhileStatement, expression: Expression, statement: Statement) => WhileStatement; - /** @deprecated Use `factory.createFor` or the factory supplied by your transformation context instead. */ - const createFor: (initializer: Expression | VariableDeclarationList | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement) => ForStatement; - /** @deprecated Use `factory.updateFor` or the factory supplied by your transformation context instead. */ - const updateFor: (node: ForStatement, initializer: Expression | VariableDeclarationList | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement) => ForStatement; - /** @deprecated Use `factory.createForIn` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createForStatement` or the factory supplied by your transformation context instead. */ + const createFor: (initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement) => ForStatement; + /** @deprecated Use `factory.updateForStatement` or the factory supplied by your transformation context instead. */ + const updateFor: (node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement) => ForStatement; + /** @deprecated Use `factory.createForInStatement` or the factory supplied by your transformation context instead. */ const createForIn: (initializer: ForInitializer, expression: Expression, statement: Statement) => ForInStatement; - /** @deprecated Use `factory.updateForIn` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateForInStatement` or the factory supplied by your transformation context instead. */ const updateForIn: (node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement) => ForInStatement; - /** @deprecated Use `factory.createForOf` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createForOfStatement` or the factory supplied by your transformation context instead. */ const createForOf: (awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement) => ForOfStatement; - /** @deprecated Use `factory.updateForOf` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateForOfStatement` or the factory supplied by your transformation context instead. */ const updateForOf: (node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement) => ForOfStatement; - /** @deprecated Use `factory.createContinue` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createContinueStatement` or the factory supplied by your transformation context instead. */ const createContinue: (label?: string | Identifier | undefined) => ContinueStatement; - /** @deprecated Use `factory.updateContinue` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateContinueStatement` or the factory supplied by your transformation context instead. */ const updateContinue: (node: ContinueStatement, label: Identifier | undefined) => ContinueStatement; - /** @deprecated Use `factory.createBreak` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createBreakStatement` or the factory supplied by your transformation context instead. */ const createBreak: (label?: string | Identifier | undefined) => BreakStatement; - /** @deprecated Use `factory.updateBreak` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateBreakStatement` or the factory supplied by your transformation context instead. */ const updateBreak: (node: BreakStatement, label: Identifier | undefined) => BreakStatement; - /** @deprecated Use `factory.createReturn` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createReturnStatement` or the factory supplied by your transformation context instead. */ const createReturn: (expression?: Expression | undefined) => ReturnStatement; - /** @deprecated Use `factory.updateReturn` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateReturnStatement` or the factory supplied by your transformation context instead. */ const updateReturn: (node: ReturnStatement, expression: Expression | undefined) => ReturnStatement; - /** @deprecated Use `factory.createWith` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createWithStatement` or the factory supplied by your transformation context instead. */ const createWith: (expression: Expression, statement: Statement) => WithStatement; - /** @deprecated Use `factory.updateWith` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateWithStatement` or the factory supplied by your transformation context instead. */ const updateWith: (node: WithStatement, expression: Expression, statement: Statement) => WithStatement; - /** @deprecated Use `factory.createSwitch` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createSwitchStatement` or the factory supplied by your transformation context instead. */ const createSwitch: (expression: Expression, caseBlock: CaseBlock) => SwitchStatement; - /** @deprecated Use `factory.updateSwitch` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateSwitchStatement` or the factory supplied by your transformation context instead. */ const updateSwitch: (node: SwitchStatement, expression: Expression, caseBlock: CaseBlock) => SwitchStatement; - /** @deprecated Use `factory.createLabel` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createLabelStatement` or the factory supplied by your transformation context instead. */ const createLabel: (label: string | Identifier, statement: Statement) => LabeledStatement; - /** @deprecated Use `factory.updateLabel` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateLabelStatement` or the factory supplied by your transformation context instead. */ const updateLabel: (node: LabeledStatement, label: Identifier, statement: Statement) => LabeledStatement; - /** @deprecated Use `factory.createThrow` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createThrowStatement` or the factory supplied by your transformation context instead. */ const createThrow: (expression: Expression) => ThrowStatement; - /** @deprecated Use `factory.updateThrow` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateThrowStatement` or the factory supplied by your transformation context instead. */ const updateThrow: (node: ThrowStatement, expression: Expression) => ThrowStatement; - /** @deprecated Use `factory.createTry` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createTryStatement` or the factory supplied by your transformation context instead. */ const createTry: (tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined) => TryStatement; - /** @deprecated Use `factory.updateTry` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateTryStatement` or the factory supplied by your transformation context instead. */ const updateTry: (node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined) => TryStatement; /** @deprecated Use `factory.createDebuggerStatement` or the factory supplied by your transformation context instead. */ const createDebuggerStatement: () => DebuggerStatement; @@ -6845,9 +6863,9 @@ declare namespace ts { /** @deprecated Use `factory.updateEnumDeclaration` or the factory supplied by your transformation context instead. */ const updateEnumDeclaration: (node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]) => EnumDeclaration; /** @deprecated Use `factory.createModuleDeclaration` or the factory supplied by your transformation context instead. */ - const createModuleDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: Identifier | ModuleBlock | NamespaceDeclaration | JSDocNamespaceDeclaration | undefined, flags?: NodeFlags | undefined) => ModuleDeclaration; + const createModuleDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags | undefined) => ModuleDeclaration; /** @deprecated Use `factory.updateModuleDeclaration` or the factory supplied by your transformation context instead. */ - const updateModuleDeclaration: (node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: Identifier | ModuleBlock | NamespaceDeclaration | JSDocNamespaceDeclaration | undefined) => ModuleDeclaration; + const updateModuleDeclaration: (node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined) => ModuleDeclaration; /** @deprecated Use `factory.createModuleBlock` or the factory supplied by your transformation context instead. */ const createModuleBlock: (statements: readonly Statement[]) => ModuleBlock; /** @deprecated Use `factory.updateModuleBlock` or the factory supplied by your transformation context instead. */ @@ -6861,9 +6879,9 @@ declare namespace ts { /** @deprecated Use `factory.updateNamespaceExportDeclaration` or the factory supplied by your transformation context instead. */ const updateNamespaceExportDeclaration: (node: NamespaceExportDeclaration, name: Identifier) => NamespaceExportDeclaration; /** @deprecated Use `factory.createImportEqualsDeclaration` or the factory supplied by your transformation context instead. */ - const createImportEqualsDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, moduleReference: ModuleReference) => ImportEqualsDeclaration; + const createImportEqualsDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference) => ImportEqualsDeclaration; /** @deprecated Use `factory.updateImportEqualsDeclaration` or the factory supplied by your transformation context instead. */ - const updateImportEqualsDeclaration: (node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, moduleReference: ModuleReference) => ImportEqualsDeclaration; + const updateImportEqualsDeclaration: (node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference) => ImportEqualsDeclaration; /** @deprecated Use `factory.createImportDeclaration` or the factory supplied by your transformation context instead. */ const createImportDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression) => ImportDeclaration; /** @deprecated Use `factory.updateImportDeclaration` or the factory supplied by your transformation context instead. */ @@ -7005,7 +7023,7 @@ declare namespace ts { /** @deprecated Use `factory.updateCatchClause` or the factory supplied by your transformation context instead. */ const updateCatchClause: (node: CatchClause, variableDeclaration: VariableDeclaration | undefined, block: Block) => CatchClause; /** @deprecated Use `factory.createPropertyAssignment` or the factory supplied by your transformation context instead. */ - const createPropertyAssignment: (name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, initializer: Expression) => PropertyAssignment; + const createPropertyAssignment: (name: string | PropertyName, initializer: Expression) => PropertyAssignment; /** @deprecated Use `factory.updatePropertyAssignment` or the factory supplied by your transformation context instead. */ const updatePropertyAssignment: (node: PropertyAssignment, name: PropertyName, initializer: Expression) => PropertyAssignment; /** @deprecated Use `factory.createShorthandPropertyAssignment` or the factory supplied by your transformation context instead. */ @@ -7017,7 +7035,7 @@ declare namespace ts { /** @deprecated Use `factory.updateSpreadAssignment` or the factory supplied by your transformation context instead. */ const updateSpreadAssignment: (node: SpreadAssignment, expression: Expression) => SpreadAssignment; /** @deprecated Use `factory.createEnumMember` or the factory supplied by your transformation context instead. */ - const createEnumMember: (name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, initializer?: Expression | undefined) => EnumMember; + const createEnumMember: (name: string | PropertyName, initializer?: Expression | undefined) => EnumMember; /** @deprecated Use `factory.updateEnumMember` or the factory supplied by your transformation context instead. */ const updateEnumMember: (node: EnumMember, name: PropertyName, initializer: Expression | undefined) => EnumMember; /** @deprecated Use `factory.updateSourceFile` or the factory supplied by your transformation context instead. */ @@ -7028,9 +7046,9 @@ declare namespace ts { const createPartiallyEmittedExpression: (expression: Expression, original?: Node | undefined) => PartiallyEmittedExpression; /** @deprecated Use `factory.updatePartiallyEmittedExpression` or the factory supplied by your transformation context instead. */ const updatePartiallyEmittedExpression: (node: PartiallyEmittedExpression, expression: Expression) => PartiallyEmittedExpression; - /** @deprecated Use `factory.createCommaList` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createCommaListExpression` or the factory supplied by your transformation context instead. */ const createCommaList: (elements: readonly Expression[]) => CommaListExpression; - /** @deprecated Use `factory.updateCommaList` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateCommaListExpression` or the factory supplied by your transformation context instead. */ const updateCommaList: (node: CommaListExpression, elements: readonly Expression[]) => CommaListExpression; /** @deprecated Use `factory.createBundle` or the factory supplied by your transformation context instead. */ const createBundle: (sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[] | undefined) => Bundle; @@ -7184,7 +7202,7 @@ declare namespace ts { * NOTE: It is unsafe to change any properties of a `Node` that relate to its AST children, as those changes won't be * captured with respect to transformations. * - * @deprecated Use `factory.cloneNode` instead and use `setCommentRange` or `setSourceMapRange` and avoid setting `parent`. + * @deprecated Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`. */ const getMutableClone: (node: T) => T; /** @deprecated Use `isTypeAssertionExpression` instead. */ diff --git a/packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript.js b/packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript.js index a3c7e072007b..84f8b518d49a 100644 --- a/packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript.js +++ b/packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript.js @@ -14,12 +14,10 @@ and limitations under the License. ***************************************************************************** */ "use strict"; -var __spreadArrays = (this && this.__spreadArrays) || function () { - for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; - for (var r = Array(s), k = 0, i = 0; i < il; i++) - for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) - r[k] = a[j]; - return r; +var __spreadArray = (this && this.__spreadArray) || function (to, from) { + for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) + to[j] = from[i]; + return to; }; var __assign = (this && this.__assign) || function () { __assign = Object.assign || function(t) { @@ -82,6 +80,8 @@ var __extends = (this && this.__extends) || (function () { return extendStatics(d, b); }; return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); extendStatics(d, b); function __() { this.constructor = d; } d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); @@ -286,9 +286,11 @@ var ts; (function (ts) { // WARNING: The script `configurePrerelease.ts` uses a regexp to parse out these values. // If changing the text in this section, be sure to test `configurePrerelease` too. - ts.versionMajorMinor = "4.1"; + ts.versionMajorMinor = "4.2"; + // The following is baselined as a literal template type without intervention /** The version of the TypeScript compiler release */ - ts.version = "4.1.2"; + // eslint-disable-next-line @typescript-eslint/no-inferrable-types + ts.version = "4.2.3"; /* @internal */ var Comparison; (function (Comparison) { @@ -973,7 +975,7 @@ var ts; return array1; if (!some(array1)) return array2; - return __spreadArrays(array1, array2); + return __spreadArray(__spreadArray([], array1), array2); } ts.concatenate = concatenate; function selectIndex(_, i) { @@ -1719,7 +1721,7 @@ var ts; // | 1. | i | 105 | Ascii i | // | 2. | I | 73 | Ascii I | // |-------- Special characters ------------------------------------------------------------------------| - // | 3. | \u0130 | 304 | Uppper case I with dot above | + // | 3. | \u0130 | 304 | Upper case I with dot above | // | 4. | i,\u0307 | 105,775 | i, followed by 775: Lower case of (3rd item) | // | 5. | I,\u0307 | 73,775 | I, followed by 775: Upper case of (4th item), lower case is (4th item) | // | 6. | \u0131 | 305 | Lower case i without dot, upper case is I (2nd item) | @@ -2029,11 +2031,9 @@ var ts; ts.compareBooleans = compareBooleans; /** * Given a name and a list of names that are *not* equal to the name, return a spelling suggestion if there is one that is close enough. - * Names less than length 3 only check for case-insensitive equality, not Levenshtein distance. + * Names less than length 3 only check for case-insensitive equality. * - * If there is a candidate that's the same except for case, return that. - * If there is a candidate that's within one edit of the name, return that. - * Otherwise, return the candidate with the smallest Levenshtein distance, + * find the candidate with the smallest Levenshtein distance, * except for candidates: * * With no name * * Whose length differs from the target name by more than 0.34 of the length of the name. @@ -2043,42 +2043,27 @@ var ts; */ function getSpellingSuggestion(name, candidates, getName) { var maximumLengthDifference = Math.min(2, Math.floor(name.length * 0.34)); - var bestDistance = Math.floor(name.length * 0.4) + 1; // If the best result isn't better than this, don't bother. + var bestDistance = Math.floor(name.length * 0.4) + 1; // If the best result is worse than this, don't bother. var bestCandidate; - var justCheckExactMatches = false; - var nameLowerCase = name.toLowerCase(); for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) { var candidate = candidates_1[_i]; var candidateName = getName(candidate); - if (candidateName !== undefined && Math.abs(candidateName.length - nameLowerCase.length) <= maximumLengthDifference) { - var candidateNameLowerCase = candidateName.toLowerCase(); - if (candidateNameLowerCase === nameLowerCase) { - if (candidateName === name) { - continue; - } - return candidate; - } - if (justCheckExactMatches) { + if (candidateName !== undefined && Math.abs(candidateName.length - name.length) <= maximumLengthDifference) { + if (candidateName === name) { continue; } - if (candidateName.length < 3) { - // Don't bother, user would have noticed a 2-character name having an extra character + // Only consider candidates less than 3 characters long when they differ by case. + // Otherwise, don't bother, since a user would usually notice differences of a 2-character name. + if (candidateName.length < 3 && candidateName.toLowerCase() !== name.toLowerCase()) { continue; } - // Only care about a result better than the best so far. - var distance = levenshteinWithMax(nameLowerCase, candidateNameLowerCase, bestDistance - 1); + var distance = levenshteinWithMax(name, candidateName, bestDistance - 0.1); if (distance === undefined) { continue; } - if (distance < 3) { - justCheckExactMatches = true; - bestCandidate = candidate; - } - else { - ts.Debug.assert(distance < bestDistance); // Else `levenshteinWithMax` should return undefined - bestDistance = distance; - bestCandidate = candidate; - } + ts.Debug.assert(distance < bestDistance); // Else `levenshteinWithMax` should return undefined + bestDistance = distance; + bestCandidate = candidate; } } return bestCandidate; @@ -2088,14 +2073,14 @@ var ts; var previous = new Array(s2.length + 1); var current = new Array(s2.length + 1); /** Represents any value > max. We don't care about the particular value. */ - var big = max + 1; + var big = max + 0.01; for (var i = 0; i <= s2.length; i++) { previous[i] = i; } for (var i = 1; i <= s1.length; i++) { var c1 = s1.charCodeAt(i - 1); - var minJ = i > max ? i - max : 1; - var maxJ = s2.length > max + i ? max + i : s2.length; + var minJ = Math.ceil(i > max ? i - max : 1); + var maxJ = Math.floor(s2.length > max + i ? max + i : s2.length); current[0] = i; /** Smallest value of the matrix in the ith column. */ var colMin = i; @@ -2103,9 +2088,13 @@ var ts; current[j] = big; } for (var j = minJ; j <= maxJ; j++) { + // case difference should be significantly cheaper than other differences + var substitutionDistance = s1[i - 1].toLowerCase() === s2[j - 1].toLowerCase() + ? (previous[j - 1] + 0.1) + : (previous[j - 1] + 2); var dist = c1 === s2.charCodeAt(j - 1) ? previous[j - 1] - : Math.min(/*delete*/ previous[j] + 1, /*insert*/ current[j - 1] + 1, /*substitute*/ previous[j - 1] + 2); + : Math.min(/*delete*/ previous[j] + 1, /*insert*/ current[j - 1] + 1, /*substitute*/ substitutionDistance); current[j] = dist; colMin = Math.min(colMin, dist); } @@ -2698,6 +2687,10 @@ var ts; return formatEnum(flags, ts.TypeFlags, /*isFlags*/ true); } Debug.formatTypeFlags = formatTypeFlags; + function formatSignatureFlags(flags) { + return formatEnum(flags, ts.SignatureFlags, /*isFlags*/ true); + } + Debug.formatSignatureFlags = formatSignatureFlags; function formatObjectFlags(flags) { return formatEnum(flags, ts.ObjectFlags, /*isFlags*/ true); } @@ -2885,6 +2878,10 @@ var ts; } }, }); + Object.defineProperties(ts.objectAllocator.getSignatureConstructor().prototype, { + __debugFlags: { get: function () { return formatSignatureFlags(this.flags); } }, + __debugSignatureToString: { value: function () { var _a; return (_a = this.checker) === null || _a === void 0 ? void 0 : _a.signatureToString(this); } } + }); var nodeConstructors = [ ts.objectAllocator.getNodeConstructor(), ts.objectAllocator.getIdentifierConstructor(), @@ -3408,16 +3405,22 @@ var ts; typeof PerformanceObserver === "function" && hasRequiredAPI(performance, PerformanceObserver)) { return { + // For now we always write native performance events when running in the browser. We may + // make this conditional in the future if we find that native web performance hooks + // in the browser also slow down compilation. + shouldWriteNativeEvents: true, performance: performance, PerformanceObserver: PerformanceObserver }; } } function tryGetNodePerformanceHooks() { - if (typeof module === "object" && typeof require === "function") { + if (typeof process !== "undefined" && process.nextTick && !process.browser && typeof module === "object" && typeof require === "function") { try { - var _a = require("perf_hooks"), performance_1 = _a.performance, PerformanceObserver_1 = _a.PerformanceObserver; - if (hasRequiredAPI(performance_1, PerformanceObserver_1)) { + var performance_1; + var _a = require("perf_hooks"), nodePerformance_1 = _a.performance, PerformanceObserver_1 = _a.PerformanceObserver; + if (hasRequiredAPI(nodePerformance_1, PerformanceObserver_1)) { + performance_1 = nodePerformance_1; // There is a bug in Node's performance.measure prior to 12.16.3/13.13.0 that does not // match the Web Performance API specification. Node's implementation did not allow // optional `start` and `end` arguments for `performance.measure`. @@ -3425,27 +3428,26 @@ var ts; var version_1 = new ts.Version(process.versions.node); var range = new ts.VersionRange("<12.16.3 || 13 <13.13"); if (range.test(version_1)) { - return { - performance: { - get timeOrigin() { return performance_1.timeOrigin; }, - now: function () { return performance_1.now(); }, - mark: function (name) { return performance_1.mark(name); }, - measure: function (name, start, end) { - if (start === void 0) { start = "nodeStart"; } - if (end === undefined) { - end = "__performance.measure-fix__"; - performance_1.mark(end); - } - performance_1.measure(name, start, end); - if (end === "__performance.measure-fix__") { - performance_1.clearMarks("__performance.measure-fix__"); - } + performance_1 = { + get timeOrigin() { return nodePerformance_1.timeOrigin; }, + now: function () { return nodePerformance_1.now(); }, + mark: function (name) { return nodePerformance_1.mark(name); }, + measure: function (name, start, end) { + if (start === void 0) { start = "nodeStart"; } + if (end === undefined) { + end = "__performance.measure-fix__"; + nodePerformance_1.mark(end); + } + nodePerformance_1.measure(name, start, end); + if (end === "__performance.measure-fix__") { + nodePerformance_1.clearMarks("__performance.measure-fix__"); } - }, - PerformanceObserver: PerformanceObserver_1 + } }; } return { + // By default, only write native events when generating a cpu profile or using the v8 profiler. + shouldWriteNativeEvents: false, performance: performance_1, PerformanceObserver: PerformanceObserver_1 }; @@ -3476,7 +3478,6 @@ var ts; var performance; (function (performance) { var perfHooks; - var perfObserver; // when set, indicates the implementation of `Performance` to use for user timing. // when unset, indicates user timing is unavailable or disabled. var performanceImpl; @@ -3507,6 +3508,9 @@ var ts; } performance.createTimer = createTimer; performance.nullTimer = { enter: ts.noop, exit: ts.noop }; + var enabled = false; + var timeorigin = ts.timestamp(); + var marks = new ts.Map(); var counts = new ts.Map(); var durations = new ts.Map(); /** @@ -3515,7 +3519,13 @@ var ts; * @param markName The name of the mark. */ function mark(markName) { - performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.mark(markName); + var _a; + if (enabled) { + var count = (_a = counts.get(markName)) !== null && _a !== void 0 ? _a : 0; + counts.set(markName, count + 1); + marks.set(markName, ts.timestamp()); + performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.mark(markName); + } } performance.mark = mark; /** @@ -3528,7 +3538,14 @@ var ts; * used. */ function measure(measureName, startMarkName, endMarkName) { - performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.measure(measureName, startMarkName, endMarkName); + var _a, _b; + if (enabled) { + var end = (_a = (endMarkName !== undefined ? marks.get(endMarkName) : undefined)) !== null && _a !== void 0 ? _a : ts.timestamp(); + var start = (_b = (startMarkName !== undefined ? marks.get(startMarkName) : undefined)) !== null && _b !== void 0 ? _b : timeorigin; + var previousDuration = durations.get(measureName) || 0; + durations.set(measureName, previousDuration + (end - start)); + performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.measure(measureName, startMarkName, endMarkName); + } } performance.measure = measure; /** @@ -3562,40 +3579,41 @@ var ts; * Indicates whether the performance API is enabled. */ function isEnabled() { - return !!performanceImpl; + return enabled; } performance.isEnabled = isEnabled; /** Enables (and resets) performance measurements for the compiler. */ - function enable() { - if (!performanceImpl) { + function enable(system) { + var _a; + if (system === void 0) { system = ts.sys; } + if (!enabled) { + enabled = true; perfHooks || (perfHooks = ts.tryGetNativePerformanceHooks()); - if (!perfHooks) - return false; - perfObserver || (perfObserver = new perfHooks.PerformanceObserver(updateStatisticsFromList)); - perfObserver.observe({ entryTypes: ["mark", "measure"] }); - performanceImpl = perfHooks.performance; + if (perfHooks) { + timeorigin = perfHooks.performance.timeOrigin; + // NodeJS's Web Performance API is currently slower than expected, but we'd still like + // to be able to leverage native trace events when node is run with either `--cpu-prof` + // or `--prof`, if we're running with our own `--generateCpuProfile` flag, or when + // running in debug mode (since its possible to generate a cpu profile while debugging). + if (perfHooks.shouldWriteNativeEvents || ((_a = system === null || system === void 0 ? void 0 : system.cpuProfilingEnabled) === null || _a === void 0 ? void 0 : _a.call(system)) || (system === null || system === void 0 ? void 0 : system.debugMode)) { + performanceImpl = perfHooks.performance; + } + } } return true; } performance.enable = enable; /** Disables performance measurements for the compiler. */ function disable() { - perfObserver === null || perfObserver === void 0 ? void 0 : perfObserver.disconnect(); - performanceImpl = undefined; - counts.clear(); - durations.clear(); - } - performance.disable = disable; - function updateStatisticsFromList(list) { - for (var _i = 0, _a = list.getEntriesByType("mark"); _i < _a.length; _i++) { - var mark_1 = _a[_i]; - counts.set(mark_1.name, (counts.get(mark_1.name) || 0) + 1); - } - for (var _b = 0, _c = list.getEntriesByType("measure"); _b < _c.length; _b++) { - var measure_1 = _c[_b]; - durations.set(measure_1.name, (durations.get(measure_1.name) || 0) + measure_1.duration); + if (enabled) { + marks.clear(); + counts.clear(); + durations.clear(); + performanceImpl = undefined; + enabled = false; } } + performance.disable = disable; })(performance = ts.performance || (ts.performance = {})); })(ts || (ts = {})); /* @internal */ @@ -3639,31 +3657,42 @@ var ts; /** Performance logger that will generate ETW events if possible - check for `logEvent` member, as `etwModule` will be `{}` when browserified */ ts.perfLogger = etwModule && etwModule.logEvent ? etwModule : nullLogger; })(ts || (ts = {})); +/* Tracing events for the compiler. */ /*@internal*/ -/** Tracing events for the compiler. */ var ts; (function (ts) { - var tracing; - (function (tracing) { + // enable the above using startTracing() +})(ts || (ts = {})); +// `tracingEnabled` should never be used directly, only through the above +/* @internal */ +(function (ts) { + var tracingEnabled; + (function (tracingEnabled) { + var Mode; + (function (Mode) { + Mode[Mode["Project"] = 0] = "Project"; + Mode[Mode["Build"] = 1] = "Build"; + Mode[Mode["Server"] = 2] = "Server"; + })(Mode = tracingEnabled.Mode || (tracingEnabled.Mode = {})); var fs; var traceCount = 0; - var traceFd; + var traceFd = 0; + var mode; var legendPath; var legend = []; - /** Starts tracing for the given project (unless the `fs` module is unavailable). */ - function startTracing(configFilePath, traceDir, isBuildMode) { - ts.Debug.assert(!traceFd, "Tracing already started"); + ; + /** Starts tracing for the given project. */ + function startTracing(tracingMode, traceDir, configFilePath) { + ts.Debug.assert(!ts.tracing, "Tracing already started"); if (fs === undefined) { try { fs = require("fs"); } - catch (_a) { - fs = false; + catch (e) { + throw new Error("tracing requires having fs\n(original error: " + (e.message || e) + ")"); } } - if (!fs) { - return; - } + mode = tracingMode; if (legendPath === undefined) { legendPath = ts.combinePaths(traceDir, "legend.json"); } @@ -3671,7 +3700,9 @@ var ts; if (!fs.existsSync(traceDir)) { fs.mkdirSync(traceDir, { recursive: true }); } - var countPart = isBuildMode ? "." + ++traceCount : ""; + var countPart = mode === 1 /* Build */ ? "." + process.pid + "-" + ++traceCount + : mode === 2 /* Server */ ? "." + process.pid + : ""; var tracePath = ts.combinePaths(traceDir, "trace" + countPart + ".json"); var typesPath = ts.combinePaths(traceDir, "types" + countPart + ".json"); legend.push({ @@ -3680,23 +3711,21 @@ var ts; typesPath: typesPath, }); traceFd = fs.openSync(tracePath, "w"); + ts.tracing = tracingEnabled; // only when traceFd is properly set // Start with a prefix that contains some metadata that the devtools profiler expects (also avoids a warning on import) var meta = { cat: "__metadata", ph: "M", ts: 1000 * ts.timestamp(), pid: 1, tid: 1 }; fs.writeSync(traceFd, "[\n" + [__assign({ name: "process_name", args: { name: "tsc" } }, meta), __assign({ name: "thread_name", args: { name: "Main" } }, meta), __assign(__assign({ name: "TracingStartedInBrowser" }, meta), { cat: "disabled-by-default-devtools.timeline" })] .map(function (v) { return JSON.stringify(v); }).join(",\n")); } - tracing.startTracing = startTracing; - /** Stops tracing for the in-progress project and dumps the type catalog (unless the `fs` module is unavailable). */ + tracingEnabled.startTracing = startTracing; + /** Stops tracing for the in-progress project and dumps the type catalog. */ function stopTracing(typeCatalog) { - if (!traceFd) { - ts.Debug.assert(!fs, "Tracing is not in progress"); - return; - } - ts.Debug.assert(fs); + ts.Debug.assert(ts.tracing, "Tracing is not in progress"); + ts.Debug.assert(!!typeCatalog === (mode !== 2 /* Server */)); // Have a type catalog iff not in server mode fs.writeSync(traceFd, "\n]\n"); fs.closeSync(traceFd); - traceFd = undefined; + ts.tracing = undefined; if (typeCatalog) { dumpTypes(typeCatalog); } @@ -3706,64 +3735,67 @@ var ts; legend[legend.length - 1].typesPath = undefined; } } - tracing.stopTracing = stopTracing; - function isTracing() { - return !!traceFd; - } - tracing.isTracing = isTracing; + tracingEnabled.stopTracing = stopTracing; var Phase; (function (Phase) { Phase["Parse"] = "parse"; Phase["Program"] = "program"; Phase["Bind"] = "bind"; Phase["Check"] = "check"; + Phase["CheckTypes"] = "checkTypes"; Phase["Emit"] = "emit"; - })(Phase = tracing.Phase || (tracing.Phase = {})); - /** Note: `push`/`pop` should be used by default. - * `begin`/`end` are for special cases where we need the data point even if the event never - * terminates (typically for reducing a scenario too big to trace to one that can be completed). - * In the future we might implement an exit handler to dump unfinished events which would - * deprecate these operations. - */ - function begin(phase, name, args) { - if (!traceFd) - return; - writeEvent("B", phase, name, args); - } - tracing.begin = begin; - function end(phase, name, args) { - if (!traceFd) - return; - writeEvent("E", phase, name, args); - } - tracing.end = end; + Phase["Session"] = "session"; + })(Phase = tracingEnabled.Phase || (tracingEnabled.Phase = {})); function instant(phase, name, args) { - if (!traceFd) - return; writeEvent("I", phase, name, args, "\"s\":\"g\""); } - tracing.instant = instant; - // Used for "Complete" (ph:"X") events - var completeEvents = []; - function push(phase, name, args) { - if (!traceFd) - return; - completeEvents.push({ phase: phase, name: name, args: args, time: 1000 * ts.timestamp() }); + tracingEnabled.instant = instant; + var eventStack = []; + /** + * @param separateBeginAndEnd - used for special cases where we need the trace point even if the event + * never terminates (typically for reducing a scenario too big to trace to one that can be completed). + * In the future we might implement an exit handler to dump unfinished events which would deprecate + * these operations. + */ + function push(phase, name, args, separateBeginAndEnd) { + if (separateBeginAndEnd === void 0) { separateBeginAndEnd = false; } + if (separateBeginAndEnd) { + writeEvent("B", phase, name, args); + } + eventStack.push({ phase: phase, name: name, args: args, time: 1000 * ts.timestamp(), separateBeginAndEnd: separateBeginAndEnd }); } - tracing.push = push; + tracingEnabled.push = push; function pop() { - if (!traceFd) - return; - ts.Debug.assert(completeEvents.length > 0); - var _a = completeEvents.pop(), phase = _a.phase, name = _a.name, args = _a.args, time = _a.time; - var dur = 1000 * ts.timestamp() - time; - writeEvent("X", phase, name, args, "\"dur\":" + dur, time); + ts.Debug.assert(eventStack.length > 0); + writeStackEvent(eventStack.length - 1, 1000 * ts.timestamp()); + eventStack.length--; + } + tracingEnabled.pop = pop; + function popAll() { + var endTime = 1000 * ts.timestamp(); + for (var i = eventStack.length - 1; i >= 0; i--) { + writeStackEvent(i, endTime); + } + eventStack.length = 0; + } + tracingEnabled.popAll = popAll; + // sample every 10ms + var sampleInterval = 1000 * 10; + function writeStackEvent(index, endTime) { + var _a = eventStack[index], phase = _a.phase, name = _a.name, args = _a.args, time = _a.time, separateBeginAndEnd = _a.separateBeginAndEnd; + if (separateBeginAndEnd) { + writeEvent("E", phase, name, args, /*extras*/ undefined, endTime); + } + // test if [time,endTime) straddles a sampling point + else if (sampleInterval - (time % sampleInterval) <= endTime - time) { + writeEvent("X", phase, name, args, "\"dur\":" + (endTime - time), time); + } } - tracing.pop = pop; function writeEvent(eventType, phase, name, args, extras, time) { if (time === void 0) { time = 1000 * ts.timestamp(); } - ts.Debug.assert(traceFd); - ts.Debug.assert(fs); + // In server mode, there's no easy way to dump type information, so we drop events that would require it. + if (mode === 2 /* Server */ && phase === "checkTypes" /* CheckTypes */) + return; ts.performance.mark("beginTracing"); fs.writeSync(traceFd, ",\n{\"pid\":1,\"tid\":1,\"ph\":\"" + eventType + "\",\"cat\":\"" + phase + "\",\"ts\":" + time + ",\"name\":\"" + name + "\""); if (extras) @@ -3782,7 +3814,6 @@ var ts; } function dumpTypes(types) { var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r; - ts.Debug.assert(fs); ts.performance.mark("beginDumpTypes"); var typesPath = legend[legend.length - 1].typesPath; var typesFd = fs.openSync(typesPath, "w"); @@ -3862,11 +3893,15 @@ var ts; if (!legendPath) { return; } - ts.Debug.assert(fs); fs.writeFileSync(legendPath, JSON.stringify(legend)); } - tracing.dumpLegend = dumpLegend; - })(tracing = ts.tracing || (ts.tracing = {})); + tracingEnabled.dumpLegend = dumpLegend; + })(tracingEnabled = ts.tracingEnabled || (ts.tracingEnabled = {})); +})(ts || (ts = {})); +/*@internal*/ +(function (ts) { + // define after tracingEnabled is initialized + ts.startTracing = ts.tracingEnabled.startTracing; })(ts || (ts = {})); var ts; (function (ts) { @@ -4458,12 +4493,24 @@ var ts; }()); ts.OperationCanceledException = OperationCanceledException; /*@internal*/ - var RefFileKind; - (function (RefFileKind) { - RefFileKind[RefFileKind["Import"] = 0] = "Import"; - RefFileKind[RefFileKind["ReferenceFile"] = 1] = "ReferenceFile"; - RefFileKind[RefFileKind["TypeReferenceDirective"] = 2] = "TypeReferenceDirective"; - })(RefFileKind = ts.RefFileKind || (ts.RefFileKind = {})); + var FileIncludeKind; + (function (FileIncludeKind) { + FileIncludeKind[FileIncludeKind["RootFile"] = 0] = "RootFile"; + FileIncludeKind[FileIncludeKind["SourceFromProjectReference"] = 1] = "SourceFromProjectReference"; + FileIncludeKind[FileIncludeKind["OutputFromProjectReference"] = 2] = "OutputFromProjectReference"; + FileIncludeKind[FileIncludeKind["Import"] = 3] = "Import"; + FileIncludeKind[FileIncludeKind["ReferenceFile"] = 4] = "ReferenceFile"; + FileIncludeKind[FileIncludeKind["TypeReferenceDirective"] = 5] = "TypeReferenceDirective"; + FileIncludeKind[FileIncludeKind["LibFile"] = 6] = "LibFile"; + FileIncludeKind[FileIncludeKind["LibReferenceDirective"] = 7] = "LibReferenceDirective"; + FileIncludeKind[FileIncludeKind["AutomaticTypeDirectiveFile"] = 8] = "AutomaticTypeDirectiveFile"; + })(FileIncludeKind = ts.FileIncludeKind || (ts.FileIncludeKind = {})); + /*@internal*/ + var FilePreprocessingDiagnosticsKind; + (function (FilePreprocessingDiagnosticsKind) { + FilePreprocessingDiagnosticsKind[FilePreprocessingDiagnosticsKind["FilePreprocessingReferencedDiagnostic"] = 0] = "FilePreprocessingReferencedDiagnostic"; + FilePreprocessingDiagnosticsKind[FilePreprocessingDiagnosticsKind["FilePreprocessingFileExplainingDiagnostic"] = 1] = "FilePreprocessingFileExplainingDiagnostic"; + })(FilePreprocessingDiagnosticsKind = ts.FilePreprocessingDiagnosticsKind || (ts.FilePreprocessingDiagnosticsKind = {})); /* @internal */ var StructureIsReused; (function (StructureIsReused) { @@ -4883,7 +4930,7 @@ var ts; // This *should* be every type other than null, undefined, void, and never TypeFlags[TypeFlags["Narrowable"] = 536624127] = "Narrowable"; /* @internal */ - TypeFlags[TypeFlags["NotPrimitiveUnion"] = 469647395] = "NotPrimitiveUnion"; + TypeFlags[TypeFlags["NotPrimitiveUnion"] = 468598819] = "NotPrimitiveUnion"; // The following flags are aggregated during union and intersection type construction /* @internal */ TypeFlags[TypeFlags["IncludesMask"] = 205258751] = "IncludesMask"; @@ -4973,7 +5020,10 @@ var ts; ElementFlags[ElementFlags["Optional"] = 2] = "Optional"; ElementFlags[ElementFlags["Rest"] = 4] = "Rest"; ElementFlags[ElementFlags["Variadic"] = 8] = "Variadic"; + ElementFlags[ElementFlags["Fixed"] = 3] = "Fixed"; ElementFlags[ElementFlags["Variable"] = 12] = "Variable"; + ElementFlags[ElementFlags["NonRequired"] = 14] = "NonRequired"; + ElementFlags[ElementFlags["NonRest"] = 11] = "NonRest"; })(ElementFlags = ts.ElementFlags || (ts.ElementFlags = {})); /* @internal */ var JsxReferenceKind; @@ -4991,16 +5041,19 @@ var ts; var SignatureFlags; (function (SignatureFlags) { SignatureFlags[SignatureFlags["None"] = 0] = "None"; + // Propagating flags SignatureFlags[SignatureFlags["HasRestParameter"] = 1] = "HasRestParameter"; SignatureFlags[SignatureFlags["HasLiteralTypes"] = 2] = "HasLiteralTypes"; - SignatureFlags[SignatureFlags["IsInnerCallChain"] = 4] = "IsInnerCallChain"; - SignatureFlags[SignatureFlags["IsOuterCallChain"] = 8] = "IsOuterCallChain"; - SignatureFlags[SignatureFlags["IsUntypedSignatureInJSFile"] = 16] = "IsUntypedSignatureInJSFile"; - // We do not propagate `IsInnerCallChain` to instantiated signatures, as that would result in us + SignatureFlags[SignatureFlags["Abstract"] = 4] = "Abstract"; + // Non-propagating flags + SignatureFlags[SignatureFlags["IsInnerCallChain"] = 8] = "IsInnerCallChain"; + SignatureFlags[SignatureFlags["IsOuterCallChain"] = 16] = "IsOuterCallChain"; + SignatureFlags[SignatureFlags["IsUntypedSignatureInJSFile"] = 32] = "IsUntypedSignatureInJSFile"; + // We do not propagate `IsInnerCallChain` or `IsOuterCallChain` to instantiated signatures, as that would result in us // attempting to add `| undefined` on each recursive call to `getReturnTypeOfSignature` when // instantiating the return type. - SignatureFlags[SignatureFlags["PropagatingFlags"] = 19] = "PropagatingFlags"; - SignatureFlags[SignatureFlags["CallChainFlags"] = 12] = "CallChainFlags"; + SignatureFlags[SignatureFlags["PropagatingFlags"] = 39] = "PropagatingFlags"; + SignatureFlags[SignatureFlags["CallChainFlags"] = 24] = "CallChainFlags"; })(SignatureFlags = ts.SignatureFlags || (ts.SignatureFlags = {})); var IndexKind; (function (IndexKind) { @@ -5461,29 +5514,28 @@ var ts; ExternalEmitHelpers[ExternalEmitHelpers["Generator"] = 128] = "Generator"; ExternalEmitHelpers[ExternalEmitHelpers["Values"] = 256] = "Values"; ExternalEmitHelpers[ExternalEmitHelpers["Read"] = 512] = "Read"; - ExternalEmitHelpers[ExternalEmitHelpers["Spread"] = 1024] = "Spread"; - ExternalEmitHelpers[ExternalEmitHelpers["SpreadArrays"] = 2048] = "SpreadArrays"; - ExternalEmitHelpers[ExternalEmitHelpers["Await"] = 4096] = "Await"; - ExternalEmitHelpers[ExternalEmitHelpers["AsyncGenerator"] = 8192] = "AsyncGenerator"; - ExternalEmitHelpers[ExternalEmitHelpers["AsyncDelegator"] = 16384] = "AsyncDelegator"; - ExternalEmitHelpers[ExternalEmitHelpers["AsyncValues"] = 32768] = "AsyncValues"; - ExternalEmitHelpers[ExternalEmitHelpers["ExportStar"] = 65536] = "ExportStar"; - ExternalEmitHelpers[ExternalEmitHelpers["ImportStar"] = 131072] = "ImportStar"; - ExternalEmitHelpers[ExternalEmitHelpers["ImportDefault"] = 262144] = "ImportDefault"; - ExternalEmitHelpers[ExternalEmitHelpers["MakeTemplateObject"] = 524288] = "MakeTemplateObject"; - ExternalEmitHelpers[ExternalEmitHelpers["ClassPrivateFieldGet"] = 1048576] = "ClassPrivateFieldGet"; - ExternalEmitHelpers[ExternalEmitHelpers["ClassPrivateFieldSet"] = 2097152] = "ClassPrivateFieldSet"; - ExternalEmitHelpers[ExternalEmitHelpers["CreateBinding"] = 4194304] = "CreateBinding"; + ExternalEmitHelpers[ExternalEmitHelpers["SpreadArray"] = 1024] = "SpreadArray"; + ExternalEmitHelpers[ExternalEmitHelpers["Await"] = 2048] = "Await"; + ExternalEmitHelpers[ExternalEmitHelpers["AsyncGenerator"] = 4096] = "AsyncGenerator"; + ExternalEmitHelpers[ExternalEmitHelpers["AsyncDelegator"] = 8192] = "AsyncDelegator"; + ExternalEmitHelpers[ExternalEmitHelpers["AsyncValues"] = 16384] = "AsyncValues"; + ExternalEmitHelpers[ExternalEmitHelpers["ExportStar"] = 32768] = "ExportStar"; + ExternalEmitHelpers[ExternalEmitHelpers["ImportStar"] = 65536] = "ImportStar"; + ExternalEmitHelpers[ExternalEmitHelpers["ImportDefault"] = 131072] = "ImportDefault"; + ExternalEmitHelpers[ExternalEmitHelpers["MakeTemplateObject"] = 262144] = "MakeTemplateObject"; + ExternalEmitHelpers[ExternalEmitHelpers["ClassPrivateFieldGet"] = 524288] = "ClassPrivateFieldGet"; + ExternalEmitHelpers[ExternalEmitHelpers["ClassPrivateFieldSet"] = 1048576] = "ClassPrivateFieldSet"; + ExternalEmitHelpers[ExternalEmitHelpers["CreateBinding"] = 2097152] = "CreateBinding"; ExternalEmitHelpers[ExternalEmitHelpers["FirstEmitHelper"] = 1] = "FirstEmitHelper"; - ExternalEmitHelpers[ExternalEmitHelpers["LastEmitHelper"] = 4194304] = "LastEmitHelper"; + ExternalEmitHelpers[ExternalEmitHelpers["LastEmitHelper"] = 2097152] = "LastEmitHelper"; // Helpers included by ES2015 for..of ExternalEmitHelpers[ExternalEmitHelpers["ForOfIncludes"] = 256] = "ForOfIncludes"; // Helpers included by ES2017 for..await..of - ExternalEmitHelpers[ExternalEmitHelpers["ForAwaitOfIncludes"] = 32768] = "ForAwaitOfIncludes"; + ExternalEmitHelpers[ExternalEmitHelpers["ForAwaitOfIncludes"] = 16384] = "ForAwaitOfIncludes"; // Helpers included by ES2017 async generators - ExternalEmitHelpers[ExternalEmitHelpers["AsyncGeneratorIncludes"] = 12288] = "AsyncGeneratorIncludes"; + ExternalEmitHelpers[ExternalEmitHelpers["AsyncGeneratorIncludes"] = 6144] = "AsyncGeneratorIncludes"; // Helpers included by yield* in ES2017 async generators - ExternalEmitHelpers[ExternalEmitHelpers["AsyncDelegatorIncludes"] = 53248] = "AsyncDelegatorIncludes"; + ExternalEmitHelpers[ExternalEmitHelpers["AsyncDelegatorIncludes"] = 26624] = "AsyncDelegatorIncludes"; // Helpers included by ES2015 spread ExternalEmitHelpers[ExternalEmitHelpers["SpreadIncludes"] = 1536] = "SpreadIncludes"; })(ExternalEmitHelpers = ts.ExternalEmitHelpers || (ts.ExternalEmitHelpers = {})); @@ -5681,7 +5733,7 @@ var ts; * we expect the host to correctly handle paths in our specified format. */ ts.directorySeparator = "/"; - var altDirectorySeparator = "\\"; + ts.altDirectorySeparator = "\\"; var urlSchemeSeparator = "://"; var backslashRegExp = /\\/g; //// Path Tests @@ -5802,7 +5854,7 @@ var ts; if (ch0 === 47 /* slash */ || ch0 === 92 /* backslash */) { if (path.charCodeAt(1) !== ch0) return 1; // POSIX: "/" (or non-normalized "\") - var p1 = path.indexOf(ch0 === 47 /* slash */ ? ts.directorySeparator : altDirectorySeparator, 2); + var p1 = path.indexOf(ch0 === 47 /* slash */ ? ts.directorySeparator : ts.altDirectorySeparator, 2); if (p1 < 0) return path.length; // UNC: "//server" or "\\server" return p1 + 1; // UNC: "//server/" or "\\server\" @@ -5945,7 +5997,7 @@ var ts; var rest = path.substring(rootLength).split(ts.directorySeparator); if (rest.length && !ts.lastOrUndefined(rest)) rest.pop(); - return __spreadArrays([root], rest); + return __spreadArray([root], rest); } /** * Parse a path into an array containing a root component (at index 0) and zero or more path @@ -6091,7 +6143,7 @@ var ts; for (var _i = 1; _i < arguments.length; _i++) { paths[_i - 1] = arguments[_i]; } - return normalizePath(ts.some(paths) ? combinePaths.apply(void 0, __spreadArrays([path], paths)) : normalizeSlashes(path)); + return normalizePath(ts.some(paths) ? combinePaths.apply(void 0, __spreadArray([path], paths)) : normalizeSlashes(path)); } ts.resolvePath = resolvePath; /** @@ -6274,7 +6326,7 @@ var ts; * Determines whether `fileName` starts with the specified `directoryName` using the provided path canonicalization callback. * Comparison is case-sensitive between the canonical paths. * - * @deprecated Use `containsPath` if possible. + * Use `containsPath` if file names are not already reduced and absolute. */ function startsWithDirectory(fileName, directoryName, getCanonicalFileName) { var canonicalFileName = getCanonicalFileName(fileName); @@ -6302,7 +6354,7 @@ var ts; for (; start < fromComponents.length; start++) { relative.push(".."); } - return __spreadArrays([""], relative, components); + return __spreadArray(__spreadArray([""], relative), components); } ts.getPathComponentsRelativeTo = getPathComponentsRelativeTo; function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) { @@ -6719,16 +6771,17 @@ var ts; * (eg on OS that dont support recursive watch using fs.watch use fs.watchFile) */ /*@internal*/ - function createDirectoryWatcherSupportingRecursive(host) { + function createDirectoryWatcherSupportingRecursive(_a) { + var watchDirectory = _a.watchDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, directoryExists = _a.directoryExists, realpath = _a.realpath, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout; var cache = new ts.Map(); var callbackCache = ts.createMultiMap(); var cacheToUpdateChildWatches = new ts.Map(); var timerToUpdateChildWatches; - var filePathComparer = ts.getStringComparer(!host.useCaseSensitiveFileNames); - var toCanonicalFilePath = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames); + var filePathComparer = ts.getStringComparer(!useCaseSensitiveFileNames); + var toCanonicalFilePath = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); return function (dirName, callback, recursive, options) { return recursive ? createDirectoryWatcher(dirName, options, callback) : - host.watchDirectory(dirName, callback, recursive, options); }; + watchDirectory(dirName, callback, recursive, options); }; /** * Create the directory watcher for the dirPath. */ @@ -6740,8 +6793,8 @@ var ts; } else { directoryWatcher = { - watcher: host.watchDirectory(dirName, function (fileName) { - if (isIgnoredPath(fileName)) + watcher: watchDirectory(dirName, function (fileName) { + if (isIgnoredPath(fileName, options)) return; if (options === null || options === void 0 ? void 0 : options.synchronousWatchDirectory) { // Call the actual callback @@ -6819,7 +6872,7 @@ var ts; function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) { // Iterate through existing children and update the watches if needed var parentWatcher = cache.get(dirPath); - if (parentWatcher && host.directoryExists(dirName)) { + if (parentWatcher && directoryExists(dirName)) { // Schedule the update and postpone invoke for callbacks scheduleUpdateChildWatches(dirName, dirPath, fileName, options); return; @@ -6837,10 +6890,10 @@ var ts; cacheToUpdateChildWatches.set(dirPath, { dirName: dirName, options: options, fileNames: [fileName] }); } if (timerToUpdateChildWatches) { - host.clearTimeout(timerToUpdateChildWatches); + clearTimeout(timerToUpdateChildWatches); timerToUpdateChildWatches = undefined; } - timerToUpdateChildWatches = host.setTimeout(onTimerToUpdateChildWatches, 1000); + timerToUpdateChildWatches = setTimeout(onTimerToUpdateChildWatches, 1000); } function onTimerToUpdateChildWatches() { timerToUpdateChildWatches = undefined; @@ -6848,15 +6901,16 @@ var ts; var start = ts.timestamp(); var invokeMap = new ts.Map(); while (!timerToUpdateChildWatches && cacheToUpdateChildWatches.size) { - var _a = cacheToUpdateChildWatches.entries().next(), _b = _a.value, dirPath = _b[0], _c = _b[1], dirName = _c.dirName, options = _c.options, fileNames = _c.fileNames, done = _a.done; - ts.Debug.assert(!done); + var result = cacheToUpdateChildWatches.entries().next(); + ts.Debug.assert(!result.done); + var _a = result.value, dirPath = _a[0], _b = _a[1], dirName = _b.dirName, options = _b.options, fileNames = _b.fileNames; cacheToUpdateChildWatches.delete(dirPath); // Because the child refresh is fresh, we would need to invalidate whole root directory being watched // to ensure that all the changes are reflected at this time var hasChanges = updateChildWatches(dirName, dirPath, options); invokeCallbacks(dirPath, invokeMap, hasChanges ? undefined : fileNames); } - ts.sysLog("sysLog:: invokingWatchers:: " + (ts.timestamp() - start) + "ms:: " + cacheToUpdateChildWatches.size); + ts.sysLog("sysLog:: invokingWatchers:: Elapsed:: " + (ts.timestamp() - start) + "ms:: " + cacheToUpdateChildWatches.size); callbackCache.forEach(function (callbacks, rootDirName) { var existing = invokeMap.get(rootDirName); if (existing) { @@ -6872,7 +6926,7 @@ var ts; } }); var elapsed = ts.timestamp() - start; - ts.sysLog("sysLog:: Elapsed " + elapsed + "ms:: onTimerToUpdateChildWatches:: " + cacheToUpdateChildWatches.size + " " + timerToUpdateChildWatches); + ts.sysLog("sysLog:: Elapsed:: " + elapsed + "ms:: onTimerToUpdateChildWatches:: " + cacheToUpdateChildWatches.size + " " + timerToUpdateChildWatches); } function removeChildWatches(parentWatcher) { if (!parentWatcher) @@ -6891,11 +6945,11 @@ var ts; if (!parentWatcher) return false; var newChildWatches; - var hasChanges = ts.enumerateInsertsAndDeletes(host.directoryExists(parentDir) ? ts.mapDefined(host.getAccessibleSortedChildDirectories(parentDir), function (child) { + var hasChanges = ts.enumerateInsertsAndDeletes(directoryExists(parentDir) ? ts.mapDefined(getAccessibleSortedChildDirectories(parentDir), function (child) { var childFullName = ts.getNormalizedAbsolutePath(child, parentDir); // Filter our the symbolic link directories since those arent included in recursive watch // which is same behaviour when recursive: true is passed to fs.watch - return !isIgnoredPath(childFullName) && filePathComparer(childFullName, ts.normalizePath(host.realpath(childFullName))) === 0 /* EqualTo */ ? childFullName : undefined; + return !isIgnoredPath(childFullName, options) && filePathComparer(childFullName, ts.normalizePath(realpath(childFullName))) === 0 /* EqualTo */ ? childFullName : undefined; }) : ts.emptyArray, parentWatcher.childWatches, function (child, childWatcher) { return filePathComparer(child, childWatcher.dirName); }, createAndAddChildDirectoryWatcher, ts.closeFileWatcher, addChildDirectoryWatcher); parentWatcher.childWatches = newChildWatches || ts.emptyArray; return hasChanges; @@ -6913,13 +6967,14 @@ var ts; (newChildWatches || (newChildWatches = [])).push(childWatcher); } } - function isIgnoredPath(path) { - return ts.some(ts.ignoredPaths, function (searchPath) { return isInPath(path, searchPath); }); + function isIgnoredPath(path, options) { + return ts.some(ts.ignoredPaths, function (searchPath) { return isInPath(path, searchPath); }) || + isIgnoredByWatchOptions(path, options, useCaseSensitiveFileNames, getCurrentDirectory); } function isInPath(path, searchPath) { if (ts.stringContains(path, searchPath)) return true; - if (host.useCaseSensitiveFileNames) + if (useCaseSensitiveFileNames) return false; return ts.stringContains(toCanonicalFilePath(path), searchPath); } @@ -6947,20 +7002,27 @@ var ts; } }; } - function createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback) { + function isIgnoredByWatchOptions(pathToCheck, options, useCaseSensitiveFileNames, getCurrentDirectory) { + return ((options === null || options === void 0 ? void 0 : options.excludeDirectories) || (options === null || options === void 0 ? void 0 : options.excludeFiles)) && (ts.matchesExclude(pathToCheck, options === null || options === void 0 ? void 0 : options.excludeFiles, useCaseSensitiveFileNames, getCurrentDirectory()) || + ts.matchesExclude(pathToCheck, options === null || options === void 0 ? void 0 : options.excludeDirectories, useCaseSensitiveFileNames, getCurrentDirectory())); + } + function createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory) { return function (eventName, relativeFileName) { // In watchDirectory we only care about adding and removing files (when event name is // "rename"); changes made within files are handled by corresponding fileWatchers (when // event name is "change") if (eventName === "rename") { // When deleting a file, the passed baseFileName is null - callback(!relativeFileName ? directoryName : ts.normalizePath(ts.combinePaths(directoryName, relativeFileName))); + var fileName = !relativeFileName ? directoryName : ts.normalizePath(ts.combinePaths(directoryName, relativeFileName)); + if (!relativeFileName || !isIgnoredByWatchOptions(fileName, options, useCaseSensitiveFileNames, getCurrentDirectory)) { + callback(fileName); + } } }; } /*@internal*/ function createSystemWatchFunctions(_a) { - var pollingWatchFile = _a.pollingWatchFile, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatch = _a.fsWatch, fileExists = _a.fileExists, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, directoryExists = _a.directoryExists, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory; + var pollingWatchFile = _a.pollingWatchFile, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatch = _a.fsWatch, fileExists = _a.fileExists, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, directoryExists = _a.directoryExists, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory; var dynamicPollingWatchFile; var nonPollingWatchFile; var hostRecursiveDirectoryWatcher; @@ -7032,11 +7094,12 @@ var ts; } function watchDirectory(directoryName, callback, recursive, options) { if (fsSupportsRecursiveFsWatch) { - return fsWatch(directoryName, 1 /* Directory */, createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback), recursive, PollingInterval.Medium, ts.getFallbackOptions(options)); + return fsWatch(directoryName, 1 /* Directory */, createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory), recursive, PollingInterval.Medium, ts.getFallbackOptions(options)); } if (!hostRecursiveDirectoryWatcher) { hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({ useCaseSensitiveFileNames: useCaseSensitiveFileNames, + getCurrentDirectory: getCurrentDirectory, directoryExists: directoryExists, getAccessibleSortedChildDirectories: getAccessibleSortedChildDirectories, watchDirectory: nonRecursiveWatchDirectory, @@ -7049,8 +7112,8 @@ var ts; } function nonRecursiveWatchDirectory(directoryName, callback, recursive, options) { ts.Debug.assert(!recursive); - options = updateOptionsForWatchDirectory(options); - var watchDirectoryKind = ts.Debug.checkDefined(options.watchDirectory); + var watchDirectoryOptions = updateOptionsForWatchDirectory(options); + var watchDirectoryKind = ts.Debug.checkDefined(watchDirectoryOptions.watchDirectory); switch (watchDirectoryKind) { case ts.WatchDirectoryKind.FixedPollingInterval: return pollingWatchFile(directoryName, function () { return callback(directoryName); }, PollingInterval.Medium, @@ -7059,7 +7122,7 @@ var ts; return ensureDynamicPollingWatchFile()(directoryName, function () { return callback(directoryName); }, PollingInterval.Medium, /*options*/ undefined); case ts.WatchDirectoryKind.UseFsEvents: - return fsWatch(directoryName, 1 /* Directory */, createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback), recursive, PollingInterval.Medium, ts.getFallbackOptions(options)); + return fsWatch(directoryName, 1 /* Directory */, createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory), recursive, PollingInterval.Medium, ts.getFallbackOptions(watchDirectoryOptions)); default: ts.Debug.assertNever(watchDirectoryKind); } @@ -7121,6 +7184,7 @@ var ts; // not actually work. var byteOrderMarkIndicator = "\uFEFF"; function getNodeSystem() { + var _a; var nativePattern = /^native |^\([^)]+\)$|^(internal[\\/]|[a-zA-Z0-9_\s]+(\.js)?$)/; var _fs = require("fs"); var _path = require("path"); @@ -7130,11 +7194,12 @@ var ts; try { _crypto = require("crypto"); } - catch (_a) { + catch (_b) { _crypto = undefined; } var activeSession; var profilePath = "./profile.cpuprofile"; + var realpathSync = (_a = _fs.realpathSync.native) !== null && _a !== void 0 ? _a : _fs.realpathSync; var Buffer = require("buffer").Buffer; var nodeVersion = getNodeMajorVersion(); var isNode4OrLater = nodeVersion >= 4; @@ -7142,13 +7207,15 @@ var ts; var platform = _os.platform(); var useCaseSensitiveFileNames = isFileSystemCaseSensitive(); var fsSupportsRecursiveFsWatch = isNode4OrLater && (process.platform === "win32" || process.platform === "darwin"); - var _b = createSystemWatchFunctions({ + var getCurrentDirectory = ts.memoize(function () { return process.cwd(); }); + var _c = createSystemWatchFunctions({ pollingWatchFile: createSingleFileWatcherPerName(fsWatchFileWorker, useCaseSensitiveFileNames), getModifiedTime: getModifiedTime, setTimeout: setTimeout, clearTimeout: clearTimeout, fsWatch: fsWatch, useCaseSensitiveFileNames: useCaseSensitiveFileNames, + getCurrentDirectory: getCurrentDirectory, fileExists: fileExists, // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643) @@ -7159,7 +7226,7 @@ var ts; tscWatchFile: process.env.TSC_WATCHFILE, useNonPollingWatchers: process.env.TSC_NONPOLLING_WATCHER, tscWatchDirectory: process.env.TSC_WATCHDIRECTORY, - }), watchFile = _b.watchFile, watchDirectory = _b.watchDirectory; + }), watchFile = _c.watchFile, watchDirectory = _c.watchDirectory; var nodeSystem = { args: process.argv.slice(2), newLine: _os.EOL, @@ -7195,9 +7262,7 @@ var ts; getExecutingFilePath: function () { return __filename; }, - getCurrentDirectory: function () { - return process.cwd(); - }, + getCurrentDirectory: getCurrentDirectory, getDirectories: getDirectories, getEnvironmentVariable: function (name) { return process.env[name] || ""; @@ -7216,8 +7281,8 @@ var ts; }, getFileSize: function (path) { try { - var stat = _fs.statSync(path); - if (stat.isFile()) { + var stat = statSync(path); + if (stat === null || stat === void 0 ? void 0 : stat.isFile()) { return stat.size; } } @@ -7229,6 +7294,7 @@ var ts; }, enableCPUProfiler: enableCPUProfiler, disableCPUProfiler: disableCPUProfiler, + cpuProfilingEnabled: function () { return !!activeSession || ts.contains(process.execArgv, "--cpu-prof") || ts.contains(process.execArgv, "--prof"); }, realpath: realpath, debugMode: !!process.env.NODE_INSPECTOR_IPC || !!process.env.VSCODE_INSPECTOR_OPTIONS || ts.some(process.execArgv, function (arg) { return /^--(inspect|debug)(-brk)?(=\d+)?$/i.test(arg); }), tryEnableSourceMapsForHost: function () { @@ -7263,6 +7329,15 @@ var ts; } }; return nodeSystem; + /** + * `throwIfNoEntry` was added so recently that it's not in the node types. + * This helper encapsulates the mitigating usage of `any`. + * See https://github.com/nodejs/node/pull/33716 + */ + function statSync(path) { + // throwIfNoEntry will be ignored by older versions of node + return _fs.statSync(path, { throwIfNoEntry: false }); + } /** * Uses the builtin inspector APIs to capture a CPU profile * See https://nodejs.org/api/inspector.html#inspector_example_usage for details @@ -7317,20 +7392,21 @@ var ts; if (activeSession && activeSession !== "stopping") { var s_1 = activeSession; activeSession.post("Profiler.stop", function (err, _a) { + var _b; var profile = _a.profile; if (!err) { try { - if (_fs.statSync(profilePath).isDirectory()) { + if ((_b = statSync(profilePath)) === null || _b === void 0 ? void 0 : _b.isDirectory()) { profilePath = _path.join(profilePath, (new Date()).toISOString().replace(/:/g, "-") + "+P" + process.pid + ".cpuprofile"); } } - catch (_b) { + catch (_c) { // do nothing and ignore fallible fs operation } try { _fs.mkdirSync(_path.dirname(profilePath), { recursive: true }); } - catch (_c) { + catch (_d) { // do nothing and ignore fallible fs operation } _fs.writeFileSync(profilePath, JSON.stringify(cleanupPaths(profile))); @@ -7468,7 +7544,7 @@ var ts; return event === "rename" && (!relativeName || relativeName === lastDirectoryPart || - relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) === relativeName.length - lastDirectoryPartWithDirectorySeparator.length) && + (relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) !== -1 && relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) === relativeName.length - lastDirectoryPartWithDirectorySeparator.length)) && !fileSystemEntryExists(fileOrDirectory, entryKind) ? invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry) : callback(event, relativeName); @@ -7569,7 +7645,10 @@ var ts; if (typeof dirent === "string" || dirent.isSymbolicLink()) { var name = ts.combinePaths(path, entry); try { - stat = _fs.statSync(name); + stat = statSync(name); + if (!stat) { + continue; + } } catch (e) { continue; @@ -7602,7 +7681,10 @@ var ts; var originalStackTraceLimit = Error.stackTraceLimit; Error.stackTraceLimit = 0; try { - var stat = _fs.statSync(path); + var stat = statSync(path); + if (!stat) { + return false; + } switch (entryKind) { case 0 /* File */: return stat.isFile(); case 1 /* Directory */: return stat.isDirectory(); @@ -7627,15 +7709,16 @@ var ts; } function realpath(path) { try { - return _fs.realpathSync(path); + return realpathSync(path); } catch (_a) { return path; } } function getModifiedTime(path) { + var _a; try { - return _fs.statSync(path).mtime; + return (_a = statSync(path)) === null || _a === void 0 ? void 0 : _a.mtime; } catch (e) { return undefined; @@ -7771,7 +7854,7 @@ var ts; Invalid_use_of_0_in_strict_mode: diag(1100, ts.DiagnosticCategory.Error, "Invalid_use_of_0_in_strict_mode_1100", "Invalid use of '{0}' in strict mode."), with_statements_are_not_allowed_in_strict_mode: diag(1101, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_strict_mode_1101", "'with' statements are not allowed in strict mode."), delete_cannot_be_called_on_an_identifier_in_strict_mode: diag(1102, ts.DiagnosticCategory.Error, "delete_cannot_be_called_on_an_identifier_in_strict_mode_1102", "'delete' cannot be called on an identifier in strict mode."), - A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator: diag(1103, ts.DiagnosticCategory.Error, "A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator_1103", "A 'for-await-of' statement is only allowed within an async function or async generator."), + for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1103, ts.DiagnosticCategory.Error, "for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1103", "'for await' loops are only allowed within async functions and at the top levels of modules."), A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: diag(1104, ts.DiagnosticCategory.Error, "A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement_1104", "A 'continue' statement can only be used within an enclosing iteration statement."), A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: diag(1105, ts.DiagnosticCategory.Error, "A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement_1105", "A 'break' statement can only be used within an enclosing iteration or switch statement."), Jump_target_cannot_cross_function_boundary: diag(1107, ts.DiagnosticCategory.Error, "Jump_target_cannot_cross_function_boundary_1107", "Jump target cannot cross function boundary."), @@ -7905,7 +7988,6 @@ var ts; _0_tag_cannot_be_used_independently_as_a_top_level_JSDoc_tag: diag(1253, ts.DiagnosticCategory.Error, "_0_tag_cannot_be_used_independently_as_a_top_level_JSDoc_tag_1253", "'{0}' tag cannot be used independently as a top level JSDoc tag."), A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference: diag(1254, ts.DiagnosticCategory.Error, "A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_refere_1254", "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference."), A_definite_assignment_assertion_is_not_permitted_in_this_context: diag(1255, ts.DiagnosticCategory.Error, "A_definite_assignment_assertion_is_not_permitted_in_this_context_1255", "A definite assignment assertion '!' is not permitted in this context."), - A_rest_element_must_be_last_in_a_tuple_type: diag(1256, ts.DiagnosticCategory.Error, "A_rest_element_must_be_last_in_a_tuple_type_1256", "A rest element must be last in a tuple type."), A_required_element_cannot_follow_an_optional_element: diag(1257, ts.DiagnosticCategory.Error, "A_required_element_cannot_follow_an_optional_element_1257", "A required element cannot follow an optional element."), Module_0_can_only_be_default_imported_using_the_1_flag: diag(1259, ts.DiagnosticCategory.Error, "Module_0_can_only_be_default_imported_using_the_1_flag_1259", "Module '{0}' can only be default-imported using the '{1}' flag"), Keywords_cannot_contain_escape_characters: diag(1260, ts.DiagnosticCategory.Error, "Keywords_cannot_contain_escape_characters_1260", "Keywords cannot contain escape characters."), @@ -7913,6 +7995,8 @@ var ts; Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module: diag(1262, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module_1262", "Identifier expected. '{0}' is a reserved word at the top-level of a module."), Declarations_with_initializers_cannot_also_have_definite_assignment_assertions: diag(1263, ts.DiagnosticCategory.Error, "Declarations_with_initializers_cannot_also_have_definite_assignment_assertions_1263", "Declarations with initializers cannot also have definite assignment assertions."), Declarations_with_definite_assignment_assertions_must_also_have_type_annotations: diag(1264, ts.DiagnosticCategory.Error, "Declarations_with_definite_assignment_assertions_must_also_have_type_annotations_1264", "Declarations with definite assignment assertions must also have type annotations."), + A_rest_element_cannot_follow_another_rest_element: diag(1265, ts.DiagnosticCategory.Error, "A_rest_element_cannot_follow_another_rest_element_1265", "A rest element cannot follow another rest element."), + An_optional_element_cannot_follow_a_rest_element: diag(1266, ts.DiagnosticCategory.Error, "An_optional_element_cannot_follow_a_rest_element_1266", "An optional element cannot follow a rest element."), with_statements_are_not_allowed_in_an_async_function_block: diag(1300, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."), await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."), Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern: diag(1312, ts.DiagnosticCategory.Error, "Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_1312", "Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern."), @@ -7972,8 +8056,7 @@ var ts; Split_all_invalid_type_only_imports: diag(1367, ts.DiagnosticCategory.Message, "Split_all_invalid_type_only_imports_1367", "Split all invalid type-only imports"), Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(1368, ts.DiagnosticCategory.Message, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_1368", "Specify emit/checking behavior for imports that are only used for types"), Did_you_mean_0: diag(1369, ts.DiagnosticCategory.Message, "Did_you_mean_0_1369", "Did you mean '{0}'?"), - Only_ECMAScript_imports_may_use_import_type: diag(1370, ts.DiagnosticCategory.Error, "Only_ECMAScript_imports_may_use_import_type_1370", "Only ECMAScript imports may use 'import type'."), - This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is_set_to_error: diag(1371, ts.DiagnosticCategory.Error, "This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is__1371", "This import is never used as a value and must use 'import type' because the 'importsNotUsedAsValues' is set to 'error'."), + This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error: diag(1371, ts.DiagnosticCategory.Error, "This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set__1371", "This import is never used as a value and must use 'import type' because 'importsNotUsedAsValues' is set to 'error'."), Convert_to_type_only_import: diag(1373, ts.DiagnosticCategory.Message, "Convert_to_type_only_import_1373", "Convert to type-only import"), Convert_all_imports_not_used_as_a_value_to_type_only_imports: diag(1374, ts.DiagnosticCategory.Message, "Convert_all_imports_not_used_as_a_value_to_type_only_imports_1374", "Convert all imports not used as a value to type-only imports"), await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: diag(1375, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_fi_1375", "'await' expressions are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."), @@ -7991,6 +8074,49 @@ var ts; Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: diag(1387, ts.DiagnosticCategory.Error, "Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type_1387", "Function type notation must be parenthesized when used in an intersection type."), Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: diag(1388, ts.DiagnosticCategory.Error, "Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type_1388", "Constructor type notation must be parenthesized when used in an intersection type."), _0_is_not_allowed_as_a_variable_declaration_name: diag(1389, ts.DiagnosticCategory.Error, "_0_is_not_allowed_as_a_variable_declaration_name_1389", "'{0}' is not allowed as a variable declaration name."), + Provides_a_root_package_name_when_using_outFile_with_declarations: diag(1390, ts.DiagnosticCategory.Message, "Provides_a_root_package_name_when_using_outFile_with_declarations_1390", "Provides a root package name when using outFile with declarations."), + The_bundledPackageName_option_must_be_provided_when_using_outFile_and_node_module_resolution_with_declaration_emit: diag(1391, ts.DiagnosticCategory.Error, "The_bundledPackageName_option_must_be_provided_when_using_outFile_and_node_module_resolution_with_de_1391", "The `bundledPackageName` option must be provided when using outFile and node module resolution with declaration emit."), + An_import_alias_cannot_use_import_type: diag(1392, ts.DiagnosticCategory.Error, "An_import_alias_cannot_use_import_type_1392", "An import alias cannot use 'import type'"), + Imported_via_0_from_file_1: diag(1393, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_1393", "Imported via {0} from file '{1}'"), + Imported_via_0_from_file_1_with_packageId_2: diag(1394, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_with_packageId_2_1394", "Imported via {0} from file '{1}' with packageId '{2}'"), + Imported_via_0_from_file_1_to_import_importHelpers_as_specified_in_compilerOptions: diag(1395, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_to_import_importHelpers_as_specified_in_compilerOptions_1395", "Imported via {0} from file '{1}' to import 'importHelpers' as specified in compilerOptions"), + Imported_via_0_from_file_1_with_packageId_2_to_import_importHelpers_as_specified_in_compilerOptions: diag(1396, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_with_packageId_2_to_import_importHelpers_as_specified_in_compilerOptions_1396", "Imported via {0} from file '{1}' with packageId '{2}' to import 'importHelpers' as specified in compilerOptions"), + Imported_via_0_from_file_1_to_import_jsx_and_jsxs_factory_functions: diag(1397, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_to_import_jsx_and_jsxs_factory_functions_1397", "Imported via {0} from file '{1}' to import 'jsx' and 'jsxs' factory functions"), + Imported_via_0_from_file_1_with_packageId_2_to_import_jsx_and_jsxs_factory_functions: diag(1398, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_with_packageId_2_to_import_jsx_and_jsxs_factory_functions_1398", "Imported via {0} from file '{1}' with packageId '{2}' to import 'jsx' and 'jsxs' factory functions"), + File_is_included_via_import_here: diag(1399, ts.DiagnosticCategory.Message, "File_is_included_via_import_here_1399", "File is included via import here."), + Referenced_via_0_from_file_1: diag(1400, ts.DiagnosticCategory.Message, "Referenced_via_0_from_file_1_1400", "Referenced via '{0}' from file '{1}'"), + File_is_included_via_reference_here: diag(1401, ts.DiagnosticCategory.Message, "File_is_included_via_reference_here_1401", "File is included via reference here."), + Type_library_referenced_via_0_from_file_1: diag(1402, ts.DiagnosticCategory.Message, "Type_library_referenced_via_0_from_file_1_1402", "Type library referenced via '{0}' from file '{1}'"), + Type_library_referenced_via_0_from_file_1_with_packageId_2: diag(1403, ts.DiagnosticCategory.Message, "Type_library_referenced_via_0_from_file_1_with_packageId_2_1403", "Type library referenced via '{0}' from file '{1}' with packageId '{2}'"), + File_is_included_via_type_library_reference_here: diag(1404, ts.DiagnosticCategory.Message, "File_is_included_via_type_library_reference_here_1404", "File is included via type library reference here."), + Library_referenced_via_0_from_file_1: diag(1405, ts.DiagnosticCategory.Message, "Library_referenced_via_0_from_file_1_1405", "Library referenced via '{0}' from file '{1}'"), + File_is_included_via_library_reference_here: diag(1406, ts.DiagnosticCategory.Message, "File_is_included_via_library_reference_here_1406", "File is included via library reference here."), + Matched_by_include_pattern_0_in_1: diag(1407, ts.DiagnosticCategory.Message, "Matched_by_include_pattern_0_in_1_1407", "Matched by include pattern '{0}' in '{1}'"), + File_is_matched_by_include_pattern_specified_here: diag(1408, ts.DiagnosticCategory.Message, "File_is_matched_by_include_pattern_specified_here_1408", "File is matched by include pattern specified here."), + Part_of_files_list_in_tsconfig_json: diag(1409, ts.DiagnosticCategory.Message, "Part_of_files_list_in_tsconfig_json_1409", "Part of 'files' list in tsconfig.json"), + File_is_matched_by_files_list_specified_here: diag(1410, ts.DiagnosticCategory.Message, "File_is_matched_by_files_list_specified_here_1410", "File is matched by 'files' list specified here."), + Output_from_referenced_project_0_included_because_1_specified: diag(1411, ts.DiagnosticCategory.Message, "Output_from_referenced_project_0_included_because_1_specified_1411", "Output from referenced project '{0}' included because '{1}' specified"), + Output_from_referenced_project_0_included_because_module_is_specified_as_none: diag(1412, ts.DiagnosticCategory.Message, "Output_from_referenced_project_0_included_because_module_is_specified_as_none_1412", "Output from referenced project '{0}' included because '--module' is specified as 'none'"), + File_is_output_from_referenced_project_specified_here: diag(1413, ts.DiagnosticCategory.Message, "File_is_output_from_referenced_project_specified_here_1413", "File is output from referenced project specified here."), + Source_from_referenced_project_0_included_because_1_specified: diag(1414, ts.DiagnosticCategory.Message, "Source_from_referenced_project_0_included_because_1_specified_1414", "Source from referenced project '{0}' included because '{1}' specified"), + Source_from_referenced_project_0_included_because_module_is_specified_as_none: diag(1415, ts.DiagnosticCategory.Message, "Source_from_referenced_project_0_included_because_module_is_specified_as_none_1415", "Source from referenced project '{0}' included because '--module' is specified as 'none'"), + File_is_source_from_referenced_project_specified_here: diag(1416, ts.DiagnosticCategory.Message, "File_is_source_from_referenced_project_specified_here_1416", "File is source from referenced project specified here."), + Entry_point_of_type_library_0_specified_in_compilerOptions: diag(1417, ts.DiagnosticCategory.Message, "Entry_point_of_type_library_0_specified_in_compilerOptions_1417", "Entry point of type library '{0}' specified in compilerOptions"), + Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1: diag(1418, ts.DiagnosticCategory.Message, "Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1_1418", "Entry point of type library '{0}' specified in compilerOptions with packageId '{1}'"), + File_is_entry_point_of_type_library_specified_here: diag(1419, ts.DiagnosticCategory.Message, "File_is_entry_point_of_type_library_specified_here_1419", "File is entry point of type library specified here."), + Entry_point_for_implicit_type_library_0: diag(1420, ts.DiagnosticCategory.Message, "Entry_point_for_implicit_type_library_0_1420", "Entry point for implicit type library '{0}'"), + Entry_point_for_implicit_type_library_0_with_packageId_1: diag(1421, ts.DiagnosticCategory.Message, "Entry_point_for_implicit_type_library_0_with_packageId_1_1421", "Entry point for implicit type library '{0}' with packageId '{1}'"), + Library_0_specified_in_compilerOptions: diag(1422, ts.DiagnosticCategory.Message, "Library_0_specified_in_compilerOptions_1422", "Library '{0}' specified in compilerOptions"), + File_is_library_specified_here: diag(1423, ts.DiagnosticCategory.Message, "File_is_library_specified_here_1423", "File is library specified here."), + Default_library: diag(1424, ts.DiagnosticCategory.Message, "Default_library_1424", "Default library"), + Default_library_for_target_0: diag(1425, ts.DiagnosticCategory.Message, "Default_library_for_target_0_1425", "Default library for target '{0}'"), + File_is_default_library_for_target_specified_here: diag(1426, ts.DiagnosticCategory.Message, "File_is_default_library_for_target_specified_here_1426", "File is default library for target specified here."), + Root_file_specified_for_compilation: diag(1427, ts.DiagnosticCategory.Message, "Root_file_specified_for_compilation_1427", "Root file specified for compilation"), + File_is_output_of_project_reference_source_0: diag(1428, ts.DiagnosticCategory.Message, "File_is_output_of_project_reference_source_0_1428", "File is output of project reference source '{0}'"), + File_redirects_to_file_0: diag(1429, ts.DiagnosticCategory.Message, "File_redirects_to_file_0_1429", "File redirects to file '{0}'"), + The_file_is_in_the_program_because_Colon: diag(1430, ts.DiagnosticCategory.Message, "The_file_is_in_the_program_because_Colon_1430", "The file is in the program because:"), + for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: diag(1431, ts.DiagnosticCategory.Error, "for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_1431", "'for await' loops are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."), + Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_the_target_option_is_set_to_es2017_or_higher: diag(1432, ts.DiagnosticCategory.Error, "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_the_1432", "Top-level 'for await' loops are only allowed when the 'module' option is set to 'esnext' or 'system', and the 'target' option is set to 'es2017' or higher."), The_types_of_0_are_incompatible_between_these_types: diag(2200, ts.DiagnosticCategory.Error, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."), The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, ts.DiagnosticCategory.Error, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."), Call_signature_return_types_0_and_1_are_incompatible: diag(2202, ts.DiagnosticCategory.Error, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true), @@ -8058,7 +8184,7 @@ var ts; The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: diag(2358, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter."), The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: diag(2359, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_F_2359", "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type."), The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol: diag(2360, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol_2360", "The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'."), - The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: diag(2361, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter_2361", "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter."), + The_right_hand_side_of_an_in_expression_must_not_be_a_primitive: diag(2361, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_in_expression_must_not_be_a_primitive_2361", "The right-hand side of an 'in' expression must not be a primitive."), The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2362, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2362", "The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."), The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2363, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2363", "The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."), The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access: diag(2364, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access_2364", "The left-hand side of an assignment expression must be a variable or a property access."), @@ -8264,7 +8390,7 @@ var ts; Property_0_is_incompatible_with_rest_element_type: diag(2573, ts.DiagnosticCategory.Error, "Property_0_is_incompatible_with_rest_element_type_2573", "Property '{0}' is incompatible with rest element type."), A_rest_element_type_must_be_an_array_type: diag(2574, ts.DiagnosticCategory.Error, "A_rest_element_type_must_be_an_array_type_2574", "A rest element type must be an array type."), No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments: diag(2575, ts.DiagnosticCategory.Error, "No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments_2575", "No overload expects {0} arguments, but overloads do exist that expect either {1} or {2} arguments."), - Property_0_is_a_static_member_of_type_1: diag(2576, ts.DiagnosticCategory.Error, "Property_0_is_a_static_member_of_type_1_2576", "Property '{0}' is a static member of type '{1}'."), + Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead: diag(2576, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead_2576", "Property '{0}' does not exist on type '{1}'. Did you mean to access the static member '{2}' instead?"), Return_type_annotation_circularly_references_itself: diag(2577, ts.DiagnosticCategory.Error, "Return_type_annotation_circularly_references_itself_2577", "Return type annotation circularly references itself."), Unused_ts_expect_error_directive: diag(2578, ts.DiagnosticCategory.Error, "Unused_ts_expect_error_directive_2578", "Unused '@ts-expect-error' directive."), Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode: diag(2580, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashno_2580", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node`."), @@ -8308,7 +8434,11 @@ var ts; Source_has_0_element_s_but_target_allows_only_1: diag(2619, ts.DiagnosticCategory.Error, "Source_has_0_element_s_but_target_allows_only_1_2619", "Source has {0} element(s) but target allows only {1}."), Target_requires_0_element_s_but_source_may_have_fewer: diag(2620, ts.DiagnosticCategory.Error, "Target_requires_0_element_s_but_source_may_have_fewer_2620", "Target requires {0} element(s) but source may have fewer."), Target_allows_only_0_element_s_but_source_may_have_more: diag(2621, ts.DiagnosticCategory.Error, "Target_allows_only_0_element_s_but_source_may_have_more_2621", "Target allows only {0} element(s) but source may have more."), - Element_at_index_0_is_variadic_in_one_type_but_not_in_the_other: diag(2622, ts.DiagnosticCategory.Error, "Element_at_index_0_is_variadic_in_one_type_but_not_in_the_other_2622", "Element at index {0} is variadic in one type but not in the other."), + Source_provides_no_match_for_required_element_at_position_0_in_target: diag(2623, ts.DiagnosticCategory.Error, "Source_provides_no_match_for_required_element_at_position_0_in_target_2623", "Source provides no match for required element at position {0} in target."), + Source_provides_no_match_for_variadic_element_at_position_0_in_target: diag(2624, ts.DiagnosticCategory.Error, "Source_provides_no_match_for_variadic_element_at_position_0_in_target_2624", "Source provides no match for variadic element at position {0} in target."), + Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target: diag(2625, ts.DiagnosticCategory.Error, "Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target_2625", "Variadic element at position {0} in source does not match element at position {1} in target."), + Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target: diag(2626, ts.DiagnosticCategory.Error, "Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target_2626", "Type at position {0} in source is not compatible with type at position {1} in target."), + Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target: diag(2627, ts.DiagnosticCategory.Error, "Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target_2627", "Type at positions {0} through {1} in source is not compatible with type at position {2} in target."), Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."), A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: diag(2651, ts.DiagnosticCategory.Error, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."), Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: diag(2652, ts.DiagnosticCategory.Error, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."), @@ -8455,6 +8585,10 @@ var ts; Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise: diag(2794, ts.DiagnosticCategory.Error, "Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise_2794", "Expected {0} arguments, but got {1}. Did you forget to include 'void' in your type argument to 'Promise'?"), The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types: diag(2795, ts.DiagnosticCategory.Error, "The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types_2795", "The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types."), It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tagged_template_expression_which_cannot_be_invoked: diag(2796, ts.DiagnosticCategory.Error, "It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tag_2796", "It is likely that you are missing a comma to separate these two template expressions. They form a tagged template expression which cannot be invoked."), + A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_be_declared_abstract: diag(2797, ts.DiagnosticCategory.Error, "A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_2797", "A mixin class that extends from a type variable containing an abstract construct signature must also be declared 'abstract'."), + The_declaration_was_marked_as_deprecated_here: diag(2798, ts.DiagnosticCategory.Error, "The_declaration_was_marked_as_deprecated_here_2798", "The declaration was marked as deprecated here."), + Type_produces_a_tuple_type_that_is_too_large_to_represent: diag(2799, ts.DiagnosticCategory.Error, "Type_produces_a_tuple_type_that_is_too_large_to_represent_2799", "Type produces a tuple type that is too large to represent."), + Expression_produces_a_tuple_type_that_is_too_large_to_represent: diag(2800, ts.DiagnosticCategory.Error, "Expression_produces_a_tuple_type_that_is_too_large_to_represent_2800", "Expression produces a tuple type that is too large to represent."), Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."), Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."), Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."), @@ -8527,6 +8661,7 @@ var ts; Exported_type_alias_0_has_or_is_using_private_name_1: diag(4081, ts.DiagnosticCategory.Error, "Exported_type_alias_0_has_or_is_using_private_name_1_4081", "Exported type alias '{0}' has or is using private name '{1}'."), Default_export_of_the_module_has_or_is_using_private_name_0: diag(4082, ts.DiagnosticCategory.Error, "Default_export_of_the_module_has_or_is_using_private_name_0_4082", "Default export of the module has or is using private name '{0}'."), Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1: diag(4083, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1_4083", "Type parameter '{0}' of exported type alias has or is using private name '{1}'."), + Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2: diag(4084, ts.DiagnosticCategory.Error, "Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2_4084", "Exported type alias '{0}' has or is using private name '{1}' from module {2}."), Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict: diag(4090, ts.DiagnosticCategory.Error, "Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_librar_4090", "Conflicting definitions for '{0}' found at '{1}' and '{2}'. Consider installing a specific version of this library to resolve the conflict."), Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4091, ts.DiagnosticCategory.Error, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4091", "Parameter '{0}' of index signature from exported interface has or is using name '{1}' from private module '{2}'."), Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4092, ts.DiagnosticCategory.Error, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1_4092", "Parameter '{0}' of index signature from exported interface has or is using private name '{1}'."), @@ -8547,6 +8682,7 @@ var ts; Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4108, ts.DiagnosticCategory.Error, "Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4108", "Parameter '{0}' of accessor has or is using name '{1}' from external module '{2}' but cannot be named."), Type_arguments_for_0_circularly_reference_themselves: diag(4109, ts.DiagnosticCategory.Error, "Type_arguments_for_0_circularly_reference_themselves_4109", "Type arguments for '{0}' circularly reference themselves."), Tuple_type_arguments_circularly_reference_themselves: diag(4110, ts.DiagnosticCategory.Error, "Tuple_type_arguments_circularly_reference_themselves_4110", "Tuple type arguments circularly reference themselves."), + Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0: diag(4111, ts.DiagnosticCategory.Error, "Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0_4111", "Property '{0}' comes from an index signature, so it must be accessed with ['{0}']."), The_current_host_does_not_support_the_0_option: diag(5001, ts.DiagnosticCategory.Error, "The_current_host_does_not_support_the_0_option_5001", "The current host does not support the '{0}' option."), Cannot_find_the_common_subdirectory_path_for_the_input_files: diag(5009, ts.DiagnosticCategory.Error, "Cannot_find_the_common_subdirectory_path_for_the_input_files_5009", "Cannot find the common subdirectory path for the input files."), File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5010, ts.DiagnosticCategory.Error, "File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0_5010", "File specification cannot end in a recursive directory wildcard ('**'): '{0}'."), @@ -8598,6 +8734,7 @@ var ts; The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialized_A_type_annotation_is_necessary: diag(5088, ts.DiagnosticCategory.Error, "The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialize_5088", "The inferred type of '{0}' references a type with a cyclic structure which cannot be trivially serialized. A type annotation is necessary."), Option_0_cannot_be_specified_when_option_jsx_is_1: diag(5089, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_when_option_jsx_is_1_5089", "Option '{0}' cannot be specified when option 'jsx' is '{1}'."), Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash: diag(5090, ts.DiagnosticCategory.Error, "Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash_5090", "Non-relative paths are not allowed when 'baseUrl' is not set. Did you forget a leading './'?"), + Option_preserveConstEnums_cannot_be_disabled_when_isolatedModules_is_enabled: diag(5091, ts.DiagnosticCategory.Error, "Option_preserveConstEnums_cannot_be_disabled_when_isolatedModules_is_enabled_5091", "Option 'preserveConstEnums' cannot be disabled when 'isolatedModules' is enabled."), Generates_a_sourcemap_for_each_corresponding_d_ts_file: diag(6000, ts.DiagnosticCategory.Message, "Generates_a_sourcemap_for_each_corresponding_d_ts_file_6000", "Generates a sourcemap for each corresponding '.d.ts' file."), Concatenate_and_emit_output_to_single_file: diag(6001, ts.DiagnosticCategory.Message, "Concatenate_and_emit_output_to_single_file_6001", "Concatenate and emit output to single file."), Generates_corresponding_d_ts_file: diag(6002, ts.DiagnosticCategory.Message, "Generates_corresponding_d_ts_file_6002", "Generates corresponding '.d.ts' file."), @@ -8666,7 +8803,7 @@ var ts; Do_not_report_errors_on_unreachable_code: diag(6077, ts.DiagnosticCategory.Message, "Do_not_report_errors_on_unreachable_code_6077", "Do not report errors on unreachable code."), Disallow_inconsistently_cased_references_to_the_same_file: diag(6078, ts.DiagnosticCategory.Message, "Disallow_inconsistently_cased_references_to_the_same_file_6078", "Disallow inconsistently-cased references to the same file."), Specify_library_files_to_be_included_in_the_compilation: diag(6079, ts.DiagnosticCategory.Message, "Specify_library_files_to_be_included_in_the_compilation_6079", "Specify library files to be included in the compilation."), - Specify_JSX_code_generation_Colon_preserve_react_native_or_react: diag(6080, ts.DiagnosticCategory.Message, "Specify_JSX_code_generation_Colon_preserve_react_native_or_react_6080", "Specify JSX code generation: 'preserve', 'react-native', or 'react'."), + Specify_JSX_code_generation_Colon_preserve_react_native_react_react_jsx_or_react_jsxdev: diag(6080, ts.DiagnosticCategory.Message, "Specify_JSX_code_generation_Colon_preserve_react_native_react_react_jsx_or_react_jsxdev_6080", "Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'."), File_0_has_an_unsupported_extension_so_skipping_it: diag(6081, ts.DiagnosticCategory.Message, "File_0_has_an_unsupported_extension_so_skipping_it_6081", "File '{0}' has an unsupported extension, so skipping it."), Only_amd_and_system_modules_are_supported_alongside_0: diag(6082, ts.DiagnosticCategory.Error, "Only_amd_and_system_modules_are_supported_alongside_0_6082", "Only 'amd' and 'system' modules are supported alongside --{0}."), Base_directory_to_resolve_non_absolute_module_names: diag(6083, ts.DiagnosticCategory.Message, "Base_directory_to_resolve_non_absolute_module_names_6083", "Base directory to resolve non-absolute module names."), @@ -8866,13 +9003,16 @@ var ts; Skipping_build_of_project_0_because_its_dependency_1_was_not_built: diag(6382, ts.DiagnosticCategory.Message, "Skipping_build_of_project_0_because_its_dependency_1_was_not_built_6382", "Skipping build of project '{0}' because its dependency '{1}' was not built"), Project_0_can_t_be_built_because_its_dependency_1_was_not_built: diag(6383, ts.DiagnosticCategory.Message, "Project_0_can_t_be_built_because_its_dependency_1_was_not_built_6383", "Project '{0}' can't be built because its dependency '{1}' was not built"), Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it: diag(6384, ts.DiagnosticCategory.Message, "Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_di_6384", "Have recompiles in '--incremental' and '--watch' assume that changes within a file will only affect files directly depending on it."), - _0_is_deprecated: diag(6385, ts.DiagnosticCategory.Suggestion, "_0_is_deprecated_6385", "'{0}' is deprecated", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ undefined, /*reportsDeprecated*/ true), + _0_is_deprecated: diag(6385, ts.DiagnosticCategory.Suggestion, "_0_is_deprecated_6385", "'{0}' is deprecated.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ undefined, /*reportsDeprecated*/ true), Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_native_implementation_of_the_Web_Performance_API_could_not_be_found: diag(6386, ts.DiagnosticCategory.Message, "Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_nativ_6386", "Performance timings for '--diagnostics' or '--extendedDiagnostics' are not available in this session. A native implementation of the Web Performance API could not be found."), + The_signature_0_of_1_is_deprecated: diag(6387, ts.DiagnosticCategory.Suggestion, "The_signature_0_of_1_is_deprecated_6387", "The signature '{0}' of '{1}' is deprecated.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ undefined, /*reportsDeprecated*/ true), The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"), The_expected_type_comes_from_this_index_signature: diag(6501, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."), The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."), Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing: diag(6503, ts.DiagnosticCategory.Message, "Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing_6503", "Print names of files that are part of the compilation and then stop processing."), File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option: diag(6504, ts.DiagnosticCategory.Error, "File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option_6504", "File '{0}' is a JavaScript file. Did you mean to enable the 'allowJs' option?"), + Print_names_of_files_and_the_reason_they_are_part_of_the_compilation: diag(6505, ts.DiagnosticCategory.Message, "Print_names_of_files_and_the_reason_they_are_part_of_the_compilation_6505", "Print names of files and the reason they are part of the compilation."), + Require_undeclared_properties_from_index_signatures_to_use_element_accesses: diag(6803, ts.DiagnosticCategory.Error, "Require_undeclared_properties_from_index_signatures_to_use_element_accesses_6803", "Require undeclared properties from index signatures to use element accesses."), Include_undefined_in_index_signature_results: diag(6800, ts.DiagnosticCategory.Message, "Include_undefined_in_index_signature_results_6800", "Include 'undefined' in index signature results"), Variable_0_implicitly_has_an_1_type: diag(7005, ts.DiagnosticCategory.Error, "Variable_0_implicitly_has_an_1_type_7005", "Variable '{0}' implicitly has an '{1}' type."), Parameter_0_implicitly_has_an_1_type: diag(7006, ts.DiagnosticCategory.Error, "Parameter_0_implicitly_has_an_1_type_7006", "Parameter '{0}' implicitly has an '{1}' type."), @@ -8923,6 +9063,7 @@ var ts; No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1: diag(7054, ts.DiagnosticCategory.Error, "No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1_7054", "No index signature with a parameter of type '{0}' was found on type '{1}'."), _0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type: diag(7055, ts.DiagnosticCategory.Error, "_0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type_7055", "'{0}', which lacks return-type annotation, implicitly has an '{1}' yield type."), The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_type_annotation_is_needed: diag(7056, ts.DiagnosticCategory.Error, "The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_ty_7056", "The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed."), + yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation: diag(7057, ts.DiagnosticCategory.Error, "yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_t_7057", "'yield' expression implicitly results in an 'any' type because its containing generator lacks a return-type annotation."), You_cannot_rename_this_element: diag(8000, ts.DiagnosticCategory.Error, "You_cannot_rename_this_element_8000", "You cannot rename this element."), You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: diag(8001, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", "You cannot rename elements that are defined in the standard TypeScript library."), import_can_only_be_used_in_TypeScript_files: diag(8002, ts.DiagnosticCategory.Error, "import_can_only_be_used_in_TypeScript_files_8002", "'import ... =' can only be used in TypeScript files."), @@ -9175,6 +9316,21 @@ var ts; Can_only_convert_logical_AND_access_chains: diag(95142, ts.DiagnosticCategory.Message, "Can_only_convert_logical_AND_access_chains_95142", "Can only convert logical AND access chains"), Add_void_to_Promise_resolved_without_a_value: diag(95143, ts.DiagnosticCategory.Message, "Add_void_to_Promise_resolved_without_a_value_95143", "Add 'void' to Promise resolved without a value"), Add_void_to_all_Promises_resolved_without_a_value: diag(95144, ts.DiagnosticCategory.Message, "Add_void_to_all_Promises_resolved_without_a_value_95144", "Add 'void' to all Promises resolved without a value"), + Use_element_access_for_0: diag(95145, ts.DiagnosticCategory.Message, "Use_element_access_for_0_95145", "Use element access for '{0}'"), + Use_element_access_for_all_undeclared_properties: diag(95146, ts.DiagnosticCategory.Message, "Use_element_access_for_all_undeclared_properties_95146", "Use element access for all undeclared properties."), + Delete_all_unused_imports: diag(95147, ts.DiagnosticCategory.Message, "Delete_all_unused_imports_95147", "Delete all unused imports"), + Infer_function_return_type: diag(95148, ts.DiagnosticCategory.Message, "Infer_function_return_type_95148", "Infer function return type"), + Return_type_must_be_inferred_from_a_function: diag(95149, ts.DiagnosticCategory.Message, "Return_type_must_be_inferred_from_a_function_95149", "Return type must be inferred from a function"), + Could_not_determine_function_return_type: diag(95150, ts.DiagnosticCategory.Message, "Could_not_determine_function_return_type_95150", "Could not determine function return type"), + Could_not_convert_to_arrow_function: diag(95151, ts.DiagnosticCategory.Message, "Could_not_convert_to_arrow_function_95151", "Could not convert to arrow function"), + Could_not_convert_to_named_function: diag(95152, ts.DiagnosticCategory.Message, "Could_not_convert_to_named_function_95152", "Could not convert to named function"), + Could_not_convert_to_anonymous_function: diag(95153, ts.DiagnosticCategory.Message, "Could_not_convert_to_anonymous_function_95153", "Could not convert to anonymous function"), + Can_only_convert_string_concatenation: diag(95154, ts.DiagnosticCategory.Message, "Can_only_convert_string_concatenation_95154", "Can only convert string concatenation"), + Selection_is_not_a_valid_statement_or_statements: diag(95155, ts.DiagnosticCategory.Message, "Selection_is_not_a_valid_statement_or_statements_95155", "Selection is not a valid statement or statements"), + Add_missing_function_declaration_0: diag(95156, ts.DiagnosticCategory.Message, "Add_missing_function_declaration_0_95156", "Add missing function declaration '{0}'"), + Add_all_missing_function_declarations: diag(95157, ts.DiagnosticCategory.Message, "Add_all_missing_function_declarations_95157", "Add all missing function declarations"), + Method_not_implemented: diag(95158, ts.DiagnosticCategory.Message, "Method_not_implemented_95158", "Method not implemented."), + Function_not_implemented: diag(95159, ts.DiagnosticCategory.Message, "Function_not_implemented_95159", "Function not implemented."), No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, ts.DiagnosticCategory.Error, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."), Classes_may_not_have_a_field_named_constructor: diag(18006, ts.DiagnosticCategory.Error, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."), JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, ts.DiagnosticCategory.Error, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"), @@ -9979,6 +10135,7 @@ var ts; reScanJsxToken: reScanJsxToken, reScanLessThanToken: reScanLessThanToken, reScanQuestionToken: reScanQuestionToken, + reScanInvalidIdentifier: reScanInvalidIdentifier, scanJsxToken: scanJsxToken, scanJsDocToken: scanJsDocToken, scan: scan, @@ -10981,15 +11138,9 @@ var ts; } return token = 79 /* PrivateIdentifier */; default: - if (isIdentifierStart(ch, languageVersion)) { - pos += charSize(ch); - while (pos < end && isIdentifierPart(ch = codePointAt(text, pos), languageVersion)) - pos += charSize(ch); - tokenValue = text.substring(tokenPos, pos); - if (ch === 92 /* backslash */) { - tokenValue += scanIdentifierParts(); - } - return token = getIdentifierToken(); + var identifierKind = scanIdentifier(ch, languageVersion); + if (identifierKind) { + return token = identifierKind; } else if (isWhiteSpaceSingleLine(ch)) { pos += charSize(ch); @@ -11006,6 +11157,31 @@ var ts; } } } + function reScanInvalidIdentifier() { + ts.Debug.assert(token === 0 /* Unknown */, "'reScanInvalidIdentifier' should only be called when the current token is 'SyntaxKind.Unknown'."); + pos = tokenPos = startPos; + tokenFlags = 0; + var ch = codePointAt(text, pos); + var identifierKind = scanIdentifier(ch, 99 /* ESNext */); + if (identifierKind) { + return token = identifierKind; + } + pos += charSize(ch); + return token; // Still `SyntaKind.Unknown` + } + function scanIdentifier(startCharacter, languageVersion) { + var ch = startCharacter; + if (isIdentifierStart(ch, languageVersion)) { + pos += charSize(ch); + while (pos < end && isIdentifierPart(ch = codePointAt(text, pos), languageVersion)) + pos += charSize(ch); + tokenValue = text.substring(tokenPos, pos); + if (ch === 92 /* backslash */) { + tokenValue += scanIdentifierParts(); + } + return getIdentifierToken(); + } + } function reScanGreaterToken() { if (token === 31 /* GreaterThanToken */) { if (text.charCodeAt(pos) === 62 /* greaterThan */) { @@ -11204,9 +11380,11 @@ var ts; // they allow dashes function scanJsxIdentifier() { if (tokenIsIdentifierOrKeyword(token)) { - // An identifier or keyword has already been parsed - check for a `-` and then append it and everything after it to the token + // An identifier or keyword has already been parsed - check for a `-` or a single instance of `:` and then append it and + // everything after it to the token // Do note that this means that `scanJsxIdentifier` effectively _mutates_ the visible token without advancing to a new token // Any caller should be expecting this behavior and should only read the pos or token value after calling it. + var namespaceSeparator = false; while (pos < end) { var ch = text.charCodeAt(pos); if (ch === 45 /* minus */) { @@ -11214,12 +11392,23 @@ var ts; pos++; continue; } + else if (ch === 58 /* colon */ && !namespaceSeparator) { + tokenValue += ":"; + pos++; + namespaceSeparator = true; + continue; + } var oldPos = pos; tokenValue += scanIdentifierParts(); // reuse `scanIdentifierParts` so unicode escapes are handled if (pos === oldPos) { break; } } + // Do not include a trailing namespace separator in the token, since this is against the spec. + if (tokenValue.slice(-1) === ":") { + tokenValue = tokenValue.slice(0, -1); + pos--; + } } return token; } @@ -11746,19 +11935,22 @@ var ts; // nodes like variable declarations and binding elements can returned a view of their flags // that includes the modifiers from their container. i.e. flags like export/declare aren't // stored on the variable declaration directly, but on the containing variable statement - // (if it has one). Similarly, flags for let/const are store on the variable declaration + // (if it has one). Similarly, flags for let/const are stored on the variable declaration // list. By calling this function, all those flags are combined so that the client can treat // the node as if it actually had those flags. function getCombinedNodeFlags(node) { return getCombinedFlags(node, function (n) { return n.flags; }); } ts.getCombinedNodeFlags = getCombinedNodeFlags; + /* @internal */ + ts.supportedLocaleDirectories = ["cs", "de", "es", "fr", "it", "ja", "ko", "pl", "pt-br", "ru", "tr", "zh-cn", "zh-tw"]; /** * Checks to see if the locale is in the appropriate format, * and if it is, attempts to set the appropriate language. */ function validateLocaleAndSetLanguage(locale, sys, errors) { - var matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(locale.toLowerCase()); + var lowerCaseLocale = locale.toLowerCase(); + var matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(lowerCaseLocale); if (!matchResult) { if (errors) { errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1, "en", "ja-jp")); @@ -11769,7 +11961,7 @@ var ts; var territory = matchResult[3]; // First try the entire locale, then fall back to just language if that's all we have. // Either ways do not fail, and fallback to the English diagnostic strings. - if (!trySetLanguageAndTerritory(language, territory, errors)) { + if (ts.contains(ts.supportedLocaleDirectories, lowerCaseLocale) && !trySetLanguageAndTerritory(language, territory, errors)) { trySetLanguageAndTerritory(language, /*territory*/ undefined, errors); } // Set the UI locale for string collation @@ -12487,6 +12679,7 @@ var ts; case 263 /* NamespaceImport */: return node.parent.isTypeOnly; case 262 /* ImportClause */: + case 260 /* ImportEqualsDeclaration */: return node.isTypeOnly; default: return false; @@ -13629,7 +13822,7 @@ var ts; break; } } - to.splice.apply(to, __spreadArrays([statementIndex, 0], from)); + to.splice.apply(to, __spreadArray([statementIndex, 0], from)); return to; } function insertStatementAfterPrologue(to, statement, isPrologueDirective) { @@ -13876,12 +14069,12 @@ var ts; GetLiteralTextFlags[GetLiteralTextFlags["NeverAsciiEscape"] = 1] = "NeverAsciiEscape"; GetLiteralTextFlags[GetLiteralTextFlags["JsxAttributeEscape"] = 2] = "JsxAttributeEscape"; GetLiteralTextFlags[GetLiteralTextFlags["TerminateUnterminatedLiterals"] = 4] = "TerminateUnterminatedLiterals"; + GetLiteralTextFlags[GetLiteralTextFlags["AllowNumericSeparator"] = 8] = "AllowNumericSeparator"; })(GetLiteralTextFlags = ts.GetLiteralTextFlags || (ts.GetLiteralTextFlags = {})); function getLiteralText(node, sourceFile, flags) { // If we don't need to downlevel and we can reach the original source text using // the node's parent reference, then simply get the text as it was originally written. - if (!nodeIsSynthesized(node) && node.parent && !(flags & 4 /* TerminateUnterminatedLiterals */ && node.isUnterminated) && !((ts.isNumericLiteral(node) && node.numericLiteralFlags & 512 /* ContainsSeparator */) || - ts.isBigIntLiteral(node))) { + if (canUseOriginalText(node, flags)) { return getSourceTextOfNodeFromSourceFile(sourceFile, node); } // If we can't reach the original source text, use the canonical form if it's a number, @@ -13931,6 +14124,15 @@ var ts; return ts.Debug.fail("Literal kind '" + node.kind + "' not accounted for."); } ts.getLiteralText = getLiteralText; + function canUseOriginalText(node, flags) { + if (nodeIsSynthesized(node) || !node.parent || (flags & 4 /* TerminateUnterminatedLiterals */ && node.isUnterminated)) { + return false; + } + if (ts.isNumericLiteral(node) && node.numericLiteralFlags & 512 /* ContainsSeparator */) { + return !!(flags & 8 /* AllowNumericSeparator */); + } + return !ts.isBigIntLiteral(node); + } function getTextOfConstantValue(value) { return ts.isString(value) ? '"' + escapeNonAsciiString(value) + '"' : "" + value; } @@ -14146,6 +14348,10 @@ var ts; } } ts.isLateVisibilityPaintedStatement = isLateVisibilityPaintedStatement; + function hasPossibleExternalModuleReference(node) { + return isAnyImportOrReExport(node) || ts.isModuleDeclaration(node) || ts.isImportTypeNode(node) || isImportCall(node); + } + ts.hasPossibleExternalModuleReference = hasPossibleExternalModuleReference; function isAnyImportOrReExport(node) { return isAnyImportSyntax(node) || ts.isExportDeclaration(node); } @@ -14228,17 +14434,30 @@ var ts; function createDiagnosticForNodeFromMessageChain(node, messageChain, relatedInformation) { var sourceFile = getSourceFileOfNode(node); var span = getErrorSpanForNode(sourceFile, node); + return createFileDiagnosticFromMessageChain(sourceFile, span.start, span.length, messageChain, relatedInformation); + } + ts.createDiagnosticForNodeFromMessageChain = createDiagnosticForNodeFromMessageChain; + function assertDiagnosticLocation(file, start, length) { + ts.Debug.assertGreaterThanOrEqual(start, 0); + ts.Debug.assertGreaterThanOrEqual(length, 0); + if (file) { + ts.Debug.assertLessThanOrEqual(start, file.text.length); + ts.Debug.assertLessThanOrEqual(start + length, file.text.length); + } + } + function createFileDiagnosticFromMessageChain(file, start, length, messageChain, relatedInformation) { + assertDiagnosticLocation(file, start, length); return { - file: sourceFile, - start: span.start, - length: span.length, + file: file, + start: start, + length: length, code: messageChain.code, category: messageChain.category, messageText: messageChain.next ? messageChain : messageChain.messageText, relatedInformation: relatedInformation }; } - ts.createDiagnosticForNodeFromMessageChain = createDiagnosticForNodeFromMessageChain; + ts.createFileDiagnosticFromMessageChain = createFileDiagnosticFromMessageChain; function createDiagnosticForFileFromMessageChain(sourceFile, messageChain, relatedInformation) { return { file: sourceFile, @@ -14719,6 +14938,14 @@ var ts; }); } ts.getPropertyAssignment = getPropertyAssignment; + function getPropertyArrayElementValue(objectLiteral, propKey, elementValue) { + return ts.firstDefined(getPropertyAssignment(objectLiteral, propKey), function (property) { + return ts.isArrayLiteralExpression(property.initializer) ? + ts.find(property.initializer.elements, function (element) { return ts.isStringLiteral(element) && element.text === elementValue; }) : + undefined; + }); + } + ts.getPropertyArrayElementValue = getPropertyArrayElementValue; function getTsConfigObjectLiteralExpression(tsConfigSourceFile) { if (tsConfigSourceFile && tsConfigSourceFile.statements.length) { var expression = tsConfigSourceFile.statements[0].expression; @@ -15592,6 +15819,10 @@ var ts; return node.moduleReference.kind === 272 /* ExternalModuleReference */ ? node.moduleReference.expression : undefined; case 195 /* ImportType */: return isLiteralImportTypeNode(node) ? node.argument.literal : undefined; + case 203 /* CallExpression */: + return node.arguments[0]; + case 256 /* ModuleDeclaration */: + return node.name.kind === 10 /* StringLiteral */ ? node.name : undefined; default: return ts.Debug.assertNever(node); } @@ -15750,6 +15981,7 @@ var ts; return parent.parent.parent; } } + ts.getNextJSDocCommentLocation = getNextJSDocCommentLocation; /** Does the opposite of `getJSDocParameterTags`: given a JSDoc parameter, finds the parameter corresponding to it. */ function getParameterSymbolFromJSDoc(node) { if (node.symbol) { @@ -15774,20 +16006,32 @@ var ts; ts.getHostSignatureFromJSDoc = getHostSignatureFromJSDoc; function getEffectiveJSDocHost(node) { var host = getJSDocHost(node); - var decl = getSourceOfDefaultedAssignment(host) || - getSourceOfAssignment(host) || - getSingleInitializerOfVariableStatementOrPropertyDeclaration(host) || - getSingleVariableOfVariableStatement(host) || - getNestedModuleDeclaration(host) || - host; - return decl; + if (host) { + return getSourceOfDefaultedAssignment(host) + || getSourceOfAssignment(host) + || getSingleInitializerOfVariableStatementOrPropertyDeclaration(host) + || getSingleVariableOfVariableStatement(host) + || getNestedModuleDeclaration(host) + || host; + } } ts.getEffectiveJSDocHost = getEffectiveJSDocHost; - /** Use getEffectiveJSDocHost if you additionally need to look for jsdoc on parent nodes, like assignments. */ + /** Use getEffectiveJSDocHost if you additionally need to look for jsdoc on parent nodes, like assignments. */ function getJSDocHost(node) { - return ts.Debug.checkDefined(ts.findAncestor(node.parent, ts.isJSDoc)).parent; + var jsDoc = getJSDocRoot(node); + if (!jsDoc) { + return undefined; + } + var host = jsDoc.parent; + if (host && host.jsDoc && jsDoc === ts.lastOrUndefined(host.jsDoc)) { + return host; + } } ts.getJSDocHost = getJSDocHost; + function getJSDocRoot(node) { + return ts.findAncestor(node.parent, ts.isJSDoc); + } + ts.getJSDocRoot = getJSDocRoot; function getTypeParameterFromJsDoc(node) { var name = node.name.escapedText; var typeParameters = node.parent.parent.parent.typeParameters; @@ -16651,7 +16895,8 @@ var ts; return getBinaryOperatorPrecedence(operatorKind); } // TODO: Should prefix `++` and `--` be moved to the `Update` precedence? - // TODO: We are missing `TypeAssertionExpression` + case 206 /* TypeAssertionExpression */: + case 225 /* NonNullExpression */: case 214 /* PrefixUnaryExpression */: case 211 /* TypeOfExpression */: case 212 /* VoidExpression */: @@ -16668,6 +16913,8 @@ var ts; case 201 /* PropertyAccessExpression */: case 202 /* ElementAccessExpression */: return 19 /* Member */; + case 224 /* AsExpression */: + return 11 /* Relational */; case 107 /* ThisKeyword */: case 105 /* SuperKeyword */: case 78 /* Identifier */: @@ -16765,11 +17012,7 @@ var ts; lookup: lookup, getGlobalDiagnostics: getGlobalDiagnostics, getDiagnostics: getDiagnostics, - reattachFileDiagnostics: reattachFileDiagnostics }; - function reattachFileDiagnostics(newFile) { - ts.forEach(fileDiagnostics.get(newFile.fileName), function (diagnostic) { return diagnostic.file = newFile; }); - } function lookup(diagnostic) { var diagnostics; if (diagnostic.file) { @@ -16944,7 +17187,7 @@ var ts; } function isIntrinsicJsxName(name) { var ch = name.charCodeAt(0); - return (ch >= 97 /* a */ && ch <= 122 /* z */) || ts.stringContains(name, "-"); + return (ch >= 97 /* a */ && ch <= 122 /* z */) || ts.stringContains(name, "-") || ts.stringContains(name, ":"); } ts.isIntrinsicJsxName = isIntrinsicJsxName; var indentStrings = ["", " "]; @@ -17143,11 +17386,20 @@ var ts; return file.moduleName || getExternalModuleNameFromPath(host, file.fileName, referenceFile && referenceFile.fileName); } ts.getResolvedExternalModuleName = getResolvedExternalModuleName; + function getCanonicalAbsolutePath(host, path) { + return host.getCanonicalFileName(ts.getNormalizedAbsolutePath(path, host.getCurrentDirectory())); + } function getExternalModuleNameFromDeclaration(host, resolver, declaration) { var file = resolver.getExternalModuleFileFromDeclaration(declaration); if (!file || file.isDeclarationFile) { return undefined; } + // If the declaration already uses a non-relative name, and is outside the common source directory, continue to use it + var specifier = getExternalModuleName(declaration); + if (specifier && ts.isStringLiteralLike(specifier) && !ts.pathIsRelative(specifier.text) && + getCanonicalAbsolutePath(host, file.path).indexOf(getCanonicalAbsolutePath(host, ts.ensureTrailingDirectorySeparator(host.getCommonSourceDirectory()))) === -1) { + return undefined; + } return getResolvedExternalModuleName(host, file); } ts.getExternalModuleNameFromDeclaration = getExternalModuleNameFromDeclaration; @@ -17832,6 +18084,12 @@ var ts; return baseStr + "." + entityNameToString(expr.name); } } + else if (ts.isElementAccessExpression(expr)) { + var baseStr = tryGetPropertyAccessOrIdentifierToString(expr.expression); + if (baseStr !== undefined && ts.isPropertyName(expr.argumentExpression)) { + return baseStr + "." + getPropertyNameForPropertyNameNode(expr.argumentExpression); + } + } else if (ts.isIdentifier(expr)) { return ts.unescapeLeadingUnderscores(expr.escapedText); } @@ -18370,11 +18628,6 @@ var ts; }); } ts.mutateMap = mutateMap; - // Return true if the given type is the constructor type for an abstract class - function isAbstractConstructorType(type) { - return !!(getObjectFlags(type) & 16 /* Anonymous */) && !!type.symbol && isAbstractConstructorSymbol(type.symbol); - } - ts.isAbstractConstructorType = isAbstractConstructorType; function isAbstractConstructorSymbol(symbol) { if (symbol.flags & 32 /* Class */) { var declaration = getClassLikeDeclarationOfSymbol(symbol); @@ -18538,7 +18791,7 @@ var ts; } function Type(checker, flags) { this.flags = flags; - if (ts.Debug.isDebugging || ts.tracing.isTracing()) { + if (ts.Debug.isDebugging || ts.tracing) { this.checker = checker; } } @@ -18615,8 +18868,7 @@ var ts; } ts.getLocaleSpecificMessage = getLocaleSpecificMessage; function createDetachedDiagnostic(fileName, start, length, message) { - ts.Debug.assertGreaterThanOrEqual(start, 0); - ts.Debug.assertGreaterThanOrEqual(length, 0); + assertDiagnosticLocation(/*file*/ undefined, start, length); var text = getLocaleSpecificMessage(message); if (arguments.length > 4) { text = formatStringFromArgs(text, arguments, 4); @@ -18680,12 +18932,7 @@ var ts; } ts.attachFileToDiagnostics = attachFileToDiagnostics; function createFileDiagnostic(file, start, length, message) { - ts.Debug.assertGreaterThanOrEqual(start, 0); - ts.Debug.assertGreaterThanOrEqual(length, 0); - if (file) { - ts.Debug.assertLessThanOrEqual(start, file.text.length); - ts.Debug.assertLessThanOrEqual(start + length, file.text.length); - } + assertDiagnosticLocation(file, start, length); var text = getLocaleSpecificMessage(message); if (arguments.length > 4) { text = formatStringFromArgs(text, arguments, 4); @@ -18727,7 +18974,7 @@ var ts; }; } ts.createCompilerDiagnostic = createCompilerDiagnostic; - function createCompilerDiagnosticFromMessageChain(chain) { + function createCompilerDiagnosticFromMessageChain(chain, relatedInformation) { return { file: undefined, start: undefined, @@ -18735,6 +18982,7 @@ var ts; code: chain.code, category: chain.category, messageText: chain.next ? chain : chain.messageText, + relatedInformation: relatedInformation }; } ts.createCompilerDiagnosticFromMessageChain = createCompilerDiagnosticFromMessageChain; @@ -18887,6 +19135,10 @@ var ts; return !!(compilerOptions.declaration || compilerOptions.composite); } ts.getEmitDeclarations = getEmitDeclarations; + function shouldPreserveConstEnums(compilerOptions) { + return !!(compilerOptions.preserveConstEnums || compilerOptions.isolatedModules); + } + ts.shouldPreserveConstEnums = shouldPreserveConstEnums; function isIncrementalCompilation(options) { return !!(options.incremental || options.composite); } @@ -18949,19 +19201,33 @@ var ts; return true; } ts.hasZeroOrOneAsteriskCharacter = hasZeroOrOneAsteriskCharacter; - function createSymlinkCache() { + function createSymlinkCache(cwd, getCanonicalFileName) { var symlinkedDirectories; + var symlinkedDirectoriesByRealpath; var symlinkedFiles; return { getSymlinkedFiles: function () { return symlinkedFiles; }, getSymlinkedDirectories: function () { return symlinkedDirectories; }, + getSymlinkedDirectoriesByRealpath: function () { return symlinkedDirectoriesByRealpath; }, setSymlinkedFile: function (path, real) { return (symlinkedFiles || (symlinkedFiles = new ts.Map())).set(path, real); }, - setSymlinkedDirectory: function (path, directory) { return (symlinkedDirectories || (symlinkedDirectories = new ts.Map())).set(path, directory); }, + setSymlinkedDirectory: function (symlink, real) { + // Large, interconnected dependency graphs in pnpm will have a huge number of symlinks + // where both the realpath and the symlink path are inside node_modules/.pnpm. Since + // this path is never a candidate for a module specifier, we can ignore it entirely. + var symlinkPath = ts.toPath(symlink, cwd, getCanonicalFileName); + if (!containsIgnoredPath(symlinkPath)) { + symlinkPath = ts.ensureTrailingDirectorySeparator(symlinkPath); + if (real !== false && !(symlinkedDirectories === null || symlinkedDirectories === void 0 ? void 0 : symlinkedDirectories.has(symlinkPath))) { + (symlinkedDirectoriesByRealpath || (symlinkedDirectoriesByRealpath = ts.createMultiMap())).add(ts.ensureTrailingDirectorySeparator(real.realPath), symlink); + } + (symlinkedDirectories || (symlinkedDirectories = new ts.Map())).set(symlinkPath, real); + } + } }; } ts.createSymlinkCache = createSymlinkCache; function discoverProbableSymlinks(files, getCanonicalFileName, cwd) { - var cache = createSymlinkCache(); + var cache = createSymlinkCache(cwd, getCanonicalFileName); var symlinks = ts.flatten(ts.mapDefined(files, function (sf) { return sf.resolvedModules && ts.compact(ts.arrayFrom(ts.mapIterator(sf.resolvedModules.values(), function (res) { return res && res.originalPath && res.resolvedFileName !== res.originalPath ? [res.resolvedFileName, res.originalPath] : undefined; @@ -18971,15 +19237,15 @@ var ts; var _a = symlinks_1[_i], resolvedPath = _a[0], originalPath = _a[1]; var _b = guessDirectorySymlink(resolvedPath, originalPath, cwd, getCanonicalFileName) || ts.emptyArray, commonResolved = _b[0], commonOriginal = _b[1]; if (commonResolved && commonOriginal) { - cache.setSymlinkedDirectory(ts.toPath(commonOriginal, cwd, getCanonicalFileName), { real: commonResolved, realPath: ts.toPath(commonResolved, cwd, getCanonicalFileName) }); + cache.setSymlinkedDirectory(commonOriginal, { real: commonResolved, realPath: ts.toPath(commonResolved, cwd, getCanonicalFileName) }); } } return cache; } ts.discoverProbableSymlinks = discoverProbableSymlinks; function guessDirectorySymlink(a, b, cwd, getCanonicalFileName) { - var aParts = ts.getPathComponents(ts.toPath(a, cwd, getCanonicalFileName)); - var bParts = ts.getPathComponents(ts.toPath(b, cwd, getCanonicalFileName)); + var aParts = ts.getPathComponents(ts.getNormalizedAbsolutePath(a, cwd)); + var bParts = ts.getPathComponents(ts.getNormalizedAbsolutePath(b, cwd)); var isDirectory = false; while (!isNodeModulesOrScopedPackageDirectory(aParts[aParts.length - 2], getCanonicalFileName) && !isNodeModulesOrScopedPackageDirectory(bParts[bParts.length - 2], getCanonicalFileName) && @@ -19079,6 +19345,11 @@ var ts; return !/[.*?]/.test(lastPathComponent); } ts.isImplicitGlob = isImplicitGlob; + function getPatternFromSpec(spec, basePath, usage) { + var pattern = spec && getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage]); + return pattern && "^(" + pattern + ")" + (usage === "exclude" ? "($|/)" : "$"); + } + ts.getPatternFromSpec = getPatternFromSpec; function getSubPatternFromSpec(spec, basePath, usage, _a) { var singleAsteriskRegexFragment = _a.singleAsteriskRegexFragment, doubleAsteriskRegexFragment = _a.doubleAsteriskRegexFragment, replaceWildcardCharacter = _a.replaceWildcardCharacter; var subpattern = ""; @@ -19309,14 +19580,14 @@ var ts; ts.supportedTSExtensionsForExtractExtension = [".d.ts" /* Dts */, ".ts" /* Ts */, ".tsx" /* Tsx */]; ts.supportedJSExtensions = [".js" /* Js */, ".jsx" /* Jsx */]; ts.supportedJSAndJsonExtensions = [".js" /* Js */, ".jsx" /* Jsx */, ".json" /* Json */]; - var allSupportedExtensions = __spreadArrays(ts.supportedTSExtensions, ts.supportedJSExtensions); - var allSupportedExtensionsWithJson = __spreadArrays(ts.supportedTSExtensions, ts.supportedJSExtensions, [".json" /* Json */]); + var allSupportedExtensions = __spreadArray(__spreadArray([], ts.supportedTSExtensions), ts.supportedJSExtensions); + var allSupportedExtensionsWithJson = __spreadArray(__spreadArray(__spreadArray([], ts.supportedTSExtensions), ts.supportedJSExtensions), [".json" /* Json */]); function getSupportedExtensions(options, extraFileExtensions) { var needJsExtensions = options && getAllowJSCompilerOption(options); if (!extraFileExtensions || extraFileExtensions.length === 0) { return needJsExtensions ? allSupportedExtensions : ts.supportedTSExtensions; } - var extensions = __spreadArrays(needJsExtensions ? allSupportedExtensions : ts.supportedTSExtensions, ts.mapDefined(extraFileExtensions, function (x) { return x.scriptKind === 7 /* Deferred */ || needJsExtensions && isJSLike(x.scriptKind) ? x.extension : undefined; })); + var extensions = __spreadArray(__spreadArray([], needJsExtensions ? allSupportedExtensions : ts.supportedTSExtensions), ts.mapDefined(extraFileExtensions, function (x) { return x.scriptKind === 7 /* Deferred */ || needJsExtensions && isJSLike(x.scriptKind) ? x.extension : undefined; })); return ts.deduplicate(extensions, ts.equateStringsCaseSensitive, ts.compareStringsCaseSensitive); } ts.getSupportedExtensions = getSupportedExtensions; @@ -19330,7 +19601,7 @@ var ts; if (supportedExtensions === ts.supportedTSExtensions) { return ts.supportedTSExtensionsWithJson; } - return __spreadArrays(supportedExtensions, [".json" /* Json */]); + return __spreadArray(__spreadArray([], supportedExtensions), [".json" /* Json */]); } ts.getSuppoertedExtensionsWithJsonIfResolveJsonModule = getSuppoertedExtensionsWithJsonIfResolveJsonModule; function isJSLike(scriptKind) { @@ -19358,6 +19629,14 @@ var ts; return false; } ts.isSupportedSourceFileName = isSupportedSourceFileName; + function numberOfDirectorySeparators(str) { + var match = str.match(/\//g); + return match ? match.length : 0; + } + function compareNumberOfDirectorySeparators(path1, path2) { + return ts.compareValues(numberOfDirectorySeparators(path1), numberOfDirectorySeparators(path2)); + } + ts.compareNumberOfDirectorySeparators = compareNumberOfDirectorySeparators; /** * Extension boundaries by priority. Lower numbers indicate higher priorities, and are * aligned to the offset of the highest priority extension in the @@ -19548,9 +19827,11 @@ var ts; return { pos: getTokenPosOfNode(node), end: node.end }; } ts.rangeOfNode = rangeOfNode; - function rangeOfTypeParameters(typeParameters) { + function rangeOfTypeParameters(sourceFile, typeParameters) { // Include the `<>` - return { pos: typeParameters.pos - 1, end: typeParameters.end + 1 }; + var pos = typeParameters.pos - 1; + var end = ts.skipTrivia(sourceFile.text, typeParameters.end) + 1; + return { pos: pos, end: end }; } ts.rangeOfTypeParameters = rangeOfTypeParameters; function skipTypeChecking(sourceFile, options, host) { @@ -19786,6 +20067,60 @@ var ts; } } ts.setParentRecursive = setParentRecursive; + function isPackedElement(node) { + return !ts.isOmittedExpression(node); + } + /** + * Determines whether the provided node is an ArrayLiteralExpression that contains no missing elements. + */ + function isPackedArrayLiteral(node) { + return ts.isArrayLiteralExpression(node) && ts.every(node.elements, isPackedElement); + } + ts.isPackedArrayLiteral = isPackedArrayLiteral; + /** + * Indicates whether the result of an `Expression` will be unused. + * + * NOTE: This requires a node with a valid `parent` pointer. + */ + function expressionResultIsUnused(node) { + ts.Debug.assertIsDefined(node.parent); + while (true) { + var parent = node.parent; + // walk up parenthesized expressions, but keep a pointer to the top-most parenthesized expression + if (ts.isParenthesizedExpression(parent)) { + node = parent; + continue; + } + // result is unused in an expression statement, `void` expression, or the initializer or incrementer of a `for` loop + if (ts.isExpressionStatement(parent) || + ts.isVoidExpression(parent) || + ts.isForStatement(parent) && (parent.initializer === node || parent.incrementor === node)) { + return true; + } + if (ts.isCommaListExpression(parent)) { + // left side of comma is always unused + if (node !== ts.last(parent.elements)) + return true; + // right side of comma is unused if parent is unused + node = parent; + continue; + } + if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === 27 /* CommaToken */) { + // left side of comma is always unused + if (node === parent.left) + return true; + // right side of comma is unused if parent is unused + node = parent; + continue; + } + return false; + } + } + ts.expressionResultIsUnused = expressionResultIsUnused; + function containsIgnoredPath(path) { + return ts.some(ts.ignoredPaths, function (p) { return ts.stringContains(path, p); }); + } + ts.containsIgnoredPath = containsIgnoredPath; })(ts || (ts = {})); /* @internal */ var ts; @@ -21589,22 +21924,48 @@ var ts; : node; } // @api - function createConstructorTypeNode(typeParameters, parameters, type) { + function createConstructorTypeNode() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return args.length === 4 ? createConstructorTypeNode1.apply(void 0, args) : + args.length === 3 ? createConstructorTypeNode2.apply(void 0, args) : + ts.Debug.fail("Incorrect number of arguments specified."); + } + function createConstructorTypeNode1(modifiers, typeParameters, parameters, type) { var node = createBaseSignatureDeclaration(175 /* ConstructorType */, - /*decorators*/ undefined, - /*modifiers*/ undefined, + /*decorators*/ undefined, modifiers, /*name*/ undefined, typeParameters, parameters, type); node.transformFlags = 1 /* ContainsTypeScript */; return node; } + /** @deprecated */ + function createConstructorTypeNode2(typeParameters, parameters, type) { + return createConstructorTypeNode1(/*modifiers*/ undefined, typeParameters, parameters, type); + } // @api - function updateConstructorTypeNode(node, typeParameters, parameters, type) { - return node.typeParameters !== typeParameters + function updateConstructorTypeNode() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return args.length === 5 ? updateConstructorTypeNode1.apply(void 0, args) : + args.length === 4 ? updateConstructorTypeNode2.apply(void 0, args) : + ts.Debug.fail("Incorrect number of arguments specified."); + } + function updateConstructorTypeNode1(node, modifiers, typeParameters, parameters, type) { + return node.modifiers !== modifiers + || node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type - ? updateBaseSignatureDeclaration(createConstructorTypeNode(typeParameters, parameters, type), node) + ? updateBaseSignatureDeclaration(createConstructorTypeNode(modifiers, typeParameters, parameters, type), node) : node; } + /** @deprecated */ + function updateConstructorTypeNode2(node, typeParameters, parameters, type) { + return updateConstructorTypeNode1(node, node.modifiers, typeParameters, parameters, type); + } // @api function createTypeQueryNode(exprName) { var node = createBaseNode(176 /* TypeQuery */); @@ -23263,8 +23624,9 @@ var ts; : node; } // @api - function createImportEqualsDeclaration(decorators, modifiers, name, moduleReference) { + function createImportEqualsDeclaration(decorators, modifiers, isTypeOnly, name, moduleReference) { var node = createBaseNamedDeclaration(260 /* ImportEqualsDeclaration */, decorators, modifiers, name); + node.isTypeOnly = isTypeOnly; node.moduleReference = moduleReference; node.transformFlags |= propagateChildFlags(node.moduleReference); if (!ts.isExternalModuleReference(node.moduleReference)) @@ -23273,12 +23635,13 @@ var ts; return node; } // @api - function updateImportEqualsDeclaration(node, decorators, modifiers, name, moduleReference) { + function updateImportEqualsDeclaration(node, decorators, modifiers, isTypeOnly, name, moduleReference) { return node.decorators !== decorators || node.modifiers !== modifiers + || node.isTypeOnly !== isTypeOnly || node.name !== name || node.moduleReference !== moduleReference - ? update(createImportEqualsDeclaration(decorators, modifiers, name, moduleReference), node) + ? update(createImportEqualsDeclaration(decorators, modifiers, isTypeOnly, name, moduleReference), node) : node; } // @api @@ -24509,10 +24872,10 @@ var ts; /*typeArguments*/ undefined, argumentsList); } function createFunctionBindCall(target, thisArg, argumentsList) { - return createMethodCall(target, "bind", __spreadArrays([thisArg], argumentsList)); + return createMethodCall(target, "bind", __spreadArray([thisArg], argumentsList)); } function createFunctionCallCall(target, thisArg, argumentsList) { - return createMethodCall(target, "call", __spreadArrays([thisArg], argumentsList)); + return createMethodCall(target, "call", __spreadArray([thisArg], argumentsList)); } function createFunctionApplyCall(target, thisArg, argumentsExpression) { return createMethodCall(target, "apply", [thisArg, argumentsExpression]); @@ -24849,7 +25212,7 @@ var ts; function ensureUseStrict(statements) { var foundUseStrict = ts.findUseStrictPrologue(statements); if (!foundUseStrict) { - return ts.setTextRange(createNodeArray(__spreadArrays([createUseStrictPrologue()], statements)), statements); + return ts.setTextRange(createNodeArray(__spreadArray([createUseStrictPrologue()], statements)), statements); } return statements; } @@ -24916,20 +25279,20 @@ var ts; var left = ts.isNodeArray(statements) ? statements.slice() : statements; // splice other custom prologues from right into left if (rightCustomPrologueEnd > rightHoistedVariablesEnd) { - left.splice.apply(left, __spreadArrays([leftHoistedVariablesEnd, 0], declarations.slice(rightHoistedVariablesEnd, rightCustomPrologueEnd))); + left.splice.apply(left, __spreadArray([leftHoistedVariablesEnd, 0], declarations.slice(rightHoistedVariablesEnd, rightCustomPrologueEnd))); } // splice hoisted variables from right into left if (rightHoistedVariablesEnd > rightHoistedFunctionsEnd) { - left.splice.apply(left, __spreadArrays([leftHoistedFunctionsEnd, 0], declarations.slice(rightHoistedFunctionsEnd, rightHoistedVariablesEnd))); + left.splice.apply(left, __spreadArray([leftHoistedFunctionsEnd, 0], declarations.slice(rightHoistedFunctionsEnd, rightHoistedVariablesEnd))); } // splice hoisted functions from right into left if (rightHoistedFunctionsEnd > rightStandardPrologueEnd) { - left.splice.apply(left, __spreadArrays([leftStandardPrologueEnd, 0], declarations.slice(rightStandardPrologueEnd, rightHoistedFunctionsEnd))); + left.splice.apply(left, __spreadArray([leftStandardPrologueEnd, 0], declarations.slice(rightStandardPrologueEnd, rightHoistedFunctionsEnd))); } // splice standard prologues from right into left (that are not already in left) if (rightStandardPrologueEnd > 0) { if (leftStandardPrologueEnd === 0) { - left.splice.apply(left, __spreadArrays([0, 0], declarations.slice(0, rightStandardPrologueEnd))); + left.splice.apply(left, __spreadArray([0, 0], declarations.slice(0, rightStandardPrologueEnd))); } else { var leftPrologues = new ts.Map(); @@ -24974,7 +25337,7 @@ var ts; ts.isTypeAliasDeclaration(node) ? updateTypeAliasDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.type) : ts.isEnumDeclaration(node) ? updateEnumDeclaration(node, node.decorators, modifiers, node.name, node.members) : ts.isModuleDeclaration(node) ? updateModuleDeclaration(node, node.decorators, modifiers, node.name, node.body) : - ts.isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration(node, node.decorators, modifiers, node.name, node.moduleReference) : + ts.isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration(node, node.decorators, modifiers, node.isTypeOnly, node.name, node.moduleReference) : ts.isImportDeclaration(node) ? updateImportDeclaration(node, node.decorators, modifiers, node.importClause, node.moduleSpecifier) : ts.isExportAssignment(node) ? updateExportAssignment(node, node.decorators, modifiers, node.expression) : ts.isExportDeclaration(node) ? updateExportDeclaration(node, node.decorators, modifiers, node.isTypeOnly, node.exportClause, node.moduleSpecifier) : @@ -25757,8 +26120,7 @@ var ts; // ES2015 Helpers createExtendsHelper: createExtendsHelper, createTemplateObjectHelper: createTemplateObjectHelper, - createSpreadHelper: createSpreadHelper, - createSpreadArraysHelper: createSpreadArraysHelper, + createSpreadArrayHelper: createSpreadArrayHelper, // ES2015 Destructuring Helpers createValuesHelper: createValuesHelper, createReadHelper: createReadHelper, @@ -25909,16 +26271,10 @@ var ts; return factory.createCallExpression(getUnscopedHelperName("__makeTemplateObject"), /*typeArguments*/ undefined, [cooked, raw]); } - function createSpreadHelper(argumentList) { - context.requestEmitHelper(ts.readHelper); - context.requestEmitHelper(ts.spreadHelper); - return factory.createCallExpression(getUnscopedHelperName("__spread"), - /*typeArguments*/ undefined, argumentList); - } - function createSpreadArraysHelper(argumentList) { - context.requestEmitHelper(ts.spreadArraysHelper); - return factory.createCallExpression(getUnscopedHelperName("__spreadArrays"), - /*typeArguments*/ undefined, argumentList); + function createSpreadArrayHelper(to, from) { + context.requestEmitHelper(ts.spreadArrayHelper); + return factory.createCallExpression(getUnscopedHelperName("__spreadArray"), + /*typeArguments*/ undefined, [to, from]); } // ES2015 Destructuring Helpers function createValuesHelper(expression) { @@ -25943,7 +26299,7 @@ var ts; function createCreateBindingHelper(module, inputName, outputName) { context.requestEmitHelper(ts.createBindingHelper); return factory.createCallExpression(getUnscopedHelperName("__createBinding"), - /*typeArguments*/ undefined, __spreadArrays([factory.createIdentifier("exports"), module, inputName], (outputName ? [outputName] : []))); + /*typeArguments*/ undefined, __spreadArray([factory.createIdentifier("exports"), module, inputName], (outputName ? [outputName] : []))); } function createImportStarHelper(expression) { context.requestEmitHelper(ts.importStarHelper); @@ -26087,7 +26443,7 @@ var ts; importName: "__extends", scoped: false, priority: 0, - text: "\n var __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n })();" + text: "\n var __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n\n return function (d, b) {\n if (typeof b !== \"function\" && b !== null)\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n })();" }; ts.templateObjectHelper = { name: "typescript:makeTemplateObject", @@ -26102,18 +26458,11 @@ var ts; scoped: false, text: "\n var __read = (this && this.__read) || function (o, n) {\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n if (!m) return o;\n var i = m.call(o), r, ar = [], e;\n try {\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n }\n catch (error) { e = { error: error }; }\n finally {\n try {\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\n }\n finally { if (e) throw e.error; }\n }\n return ar;\n };" }; - ts.spreadHelper = { - name: "typescript:spread", - importName: "__spread", - scoped: false, - dependencies: [ts.readHelper], - text: "\n var __spread = (this && this.__spread) || function () {\n for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));\n return ar;\n };" - }; - ts.spreadArraysHelper = { - name: "typescript:spreadArrays", - importName: "__spreadArrays", + ts.spreadArrayHelper = { + name: "typescript:spreadArray", + importName: "__spreadArray", scoped: false, - text: "\n var __spreadArrays = (this && this.__spreadArrays) || function () {\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n r[k] = a[j];\n return r;\n };" + text: "\n var __spreadArray = (this && this.__spreadArray) || function (to, from) {\n for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\n to[j] = from[i];\n return to;\n };" }; // ES2015 Destructuring Helpers ts.valuesHelper = { @@ -26257,8 +26606,7 @@ var ts; ts.awaiterHelper, ts.extendsHelper, ts.templateObjectHelper, - ts.spreadHelper, - ts.spreadArraysHelper, + ts.spreadArrayHelper, ts.valuesHelper, ts.readHelper, ts.generatorHelper, @@ -26282,6 +26630,13 @@ var ts; scoped: true, text: helperString(__makeTemplateObject(["\n const ", " = (function (geti, seti) {\n const cache = Object.create(null);\n return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n })(name => super[name], (name, value) => super[name] = value);"], ["\n const ", " = (function (geti, seti) {\n const cache = Object.create(null);\n return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n })(name => super[name], (name, value) => super[name] = value);"]), "_superIndex") }; + function isCallToHelper(firstSegment, helperName) { + return ts.isCallExpression(firstSegment) + && ts.isIdentifier(firstSegment.expression) + && (ts.getEmitFlags(firstSegment.expression) & 4096 /* HelperName */) + && firstSegment.expression.escapedText === helperName; + } + ts.isCallToHelper = isCallToHelper; })(ts || (ts = {})); var ts; (function (ts) { @@ -27052,6 +27407,10 @@ var ts; return node.kind === 318 /* JSDocDeprecatedTag */; } ts.isJSDocDeprecatedTag = isJSDocDeprecatedTag; + function isJSDocSeeTag(node) { + return node.kind === 332 /* JSDocSeeTag */; + } + ts.isJSDocSeeTag = isJSDocSeeTag; function isJSDocEnumTag(node) { return node.kind === 325 /* JSDocEnumTag */; } @@ -27214,7 +27573,7 @@ var ts; ts.createForOfBindingStatement = createForOfBindingStatement; function insertLeadingStatement(factory, dest, source) { if (ts.isBlock(dest)) { - return factory.updateBlock(dest, ts.setTextRange(factory.createNodeArray(__spreadArrays([source], dest.statements)), dest.statements)); + return factory.updateBlock(dest, ts.setTextRange(factory.createNodeArray(__spreadArray([source], dest.statements)), dest.statements)); } else { return factory.createBlock(factory.createNodeArray([dest, source]), /*multiLine*/ true); @@ -27507,8 +27866,8 @@ var ts; * Otherwise, a new StringLiteral node representing the module name will be returned. */ function getExternalModuleNameLiteral(factory, importNode, sourceFile, host, resolver, compilerOptions) { - var moduleName = ts.getExternalModuleName(importNode); // TODO: GH#18217 - if (moduleName.kind === 10 /* StringLiteral */) { + var moduleName = ts.getExternalModuleName(importNode); + if (moduleName && ts.isStringLiteral(moduleName)) { return tryGetModuleNameFromDeclaration(importNode, host, factory, resolver, compilerOptions) || tryRenameExternalModule(factory, moduleName, sourceFile) || factory.cloneNode(moduleName); @@ -27522,7 +27881,7 @@ var ts; */ function tryRenameExternalModule(factory, moduleName, sourceFile) { var rename = sourceFile.renamedDependencies && sourceFile.renamedDependencies.get(moduleName.text); - return rename && factory.createStringLiteral(rename); + return rename ? factory.createStringLiteral(rename) : undefined; } /** * Get the name of a module as should be written in the emitted output. @@ -27833,7 +28192,7 @@ var ts; var PrivateIdentifierConstructor; var SourceFileConstructor; /** - * NOTE: You should not use this, it is only exported to support `createNode` in `~/src/compat/deprecations.ts`. + * NOTE: You should not use this, it is only exported to support `createNode` in `~/src/deprecatedCompat/deprecations.ts`. */ /* @internal */ ts.parseBaseNodeFactory = { @@ -28364,63 +28723,58 @@ var ts; * and while doing so, handles traversing the structure without relying on the callstack to encode the tree structure. */ function forEachChildRecursively(rootNode, cbNode, cbNodes) { - var stack = [rootNode]; - while (stack.length) { - var parent = stack.pop(); - var res = visitAllPossibleChildren(parent, gatherPossibleChildren(parent)); - if (res) { - return res; - } - } - return; - function gatherPossibleChildren(node) { - var children = []; - forEachChild(node, addWorkItem, addWorkItem); // By using a stack above and `unshift` here, we emulate a depth-first preorder traversal - return children; - function addWorkItem(n) { - children.unshift(n); - } - } - function visitAllPossibleChildren(parent, children) { - for (var _i = 0, children_5 = children; _i < children_5.length; _i++) { - var child = children_5[_i]; - if (ts.isArray(child)) { - if (cbNodes) { - var res = cbNodes(child, parent); - if (res) { - if (res === "skip") - continue; - return res; - } - } - for (var i = child.length - 1; i >= 0; i--) { - var realChild = child[i]; - var res = cbNode(realChild, parent); - if (res) { - if (res === "skip") - continue; - return res; - } - stack.push(realChild); - } - } - else { - stack.push(child); - var res = cbNode(child, parent); + var queue = gatherPossibleChildren(rootNode); + var parents = []; // tracks parent references for elements in queue + while (parents.length < queue.length) { + parents.push(rootNode); + } + while (queue.length !== 0) { + var current = queue.pop(); + var parent = parents.pop(); + if (ts.isArray(current)) { + if (cbNodes) { + var res = cbNodes(current, parent); if (res) { if (res === "skip") continue; return res; } } + for (var i = current.length - 1; i >= 0; --i) { + queue.push(current[i]); + parents.push(parent); + } + } + else { + var res = cbNode(current, parent); + if (res) { + if (res === "skip") + continue; + return res; + } + if (current.kind >= 157 /* FirstNode */) { + // add children in reverse order to the queue, so popping gives the first child + for (var _i = 0, _a = gatherPossibleChildren(current); _i < _a.length; _i++) { + var child = _a[_i]; + queue.push(child); + parents.push(current); + } + } } } } ts.forEachChildRecursively = forEachChildRecursively; + function gatherPossibleChildren(node) { + var children = []; + forEachChild(node, addWorkItem, addWorkItem); // By using a stack above and `unshift` here, we emulate a depth-first preorder traversal + return children; + function addWorkItem(n) { + children.unshift(n); + } + } function createSourceFile(fileName, sourceText, languageVersion, setParentNodes, scriptKind) { if (setParentNodes === void 0) { setParentNodes = false; } - var tracingData = ["parse" /* Parse */, "createSourceFile", { path: fileName }]; - ts.tracing.begin.apply(ts.tracing, tracingData); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("parse" /* Parse */, "createSourceFile", { path: fileName }, /*separateBeginAndEnd*/ true); ts.performance.mark("beforeParse"); var result; ts.perfLogger.logStartParseSourceFile(fileName); @@ -28433,7 +28787,7 @@ var ts; ts.perfLogger.logStopParseSourceFile(); ts.performance.mark("afterParse"); ts.performance.measure("Parse", "beforeParse", "afterParse"); - ts.tracing.end.apply(ts.tracing, tracingData); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); return result; } ts.createSourceFile = createSourceFile; @@ -29309,8 +29663,8 @@ var ts; // with magic property names like '__proto__'. The 'identifiers' object is used to share a single string instance for // each identifier in order to reduce memory consumption. function createIdentifier(isIdentifier, diagnosticMessage, privateIdentifierDiagnosticMessage) { - identifierCount++; if (isIdentifier) { + identifierCount++; var pos = getNodePos(); // Store original token kind if it is not just an Identifier so we can report appropriate error later in type checker var originalKeywordKind = token(); @@ -29322,6 +29676,11 @@ var ts; parseErrorAtCurrentToken(privateIdentifierDiagnosticMessage || ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies); return createIdentifier(/*isIdentifier*/ true); } + if (token() === 0 /* Unknown */ && scanner.tryScan(function () { return scanner.reScanInvalidIdentifier() === 78 /* Identifier */; })) { + // Scanner has already recorded an 'Invalid character' error, so no need to add another from the parser. + return createIdentifier(/*isIdentifier*/ true); + } + identifierCount++; // Only for end of file because the error gets reported incorrectly on embedded script tags. var reportAtCurrentPosition = token() === 1 /* EndOfFileToken */; var isReservedWord = scanner.isReservedWord(); @@ -29415,6 +29774,7 @@ var ts; case 87 /* DefaultKeyword */: return nextTokenCanFollowDefaultKeyword(); case 123 /* StaticKeyword */: + return nextTokenIsOnSameLineAndCanFollowModifier(); case 134 /* GetKeyword */: case 146 /* SetKeyword */: nextToken(); @@ -30763,16 +31123,29 @@ var ts; parseExpected(21 /* CloseParenToken */); return finishNode(factory.createParenthesizedType(type), pos); } + function parseModifiersForConstructorType() { + var modifiers; + if (token() === 125 /* AbstractKeyword */) { + var pos = getNodePos(); + nextToken(); + var modifier = finishNode(factory.createToken(125 /* AbstractKeyword */), pos); + modifiers = createNodeArray([modifier], pos); + } + return modifiers; + } function parseFunctionOrConstructorType() { var pos = getNodePos(); var hasJSDoc = hasPrecedingJSDocComment(); + var modifiers = parseModifiersForConstructorType(); var isConstructorType = parseOptional(102 /* NewKeyword */); var typeParameters = parseTypeParameters(); var parameters = parseParameters(4 /* Type */); var type = parseReturnType(38 /* EqualsGreaterThanToken */, /*isType*/ false); var node = isConstructorType - ? factory.createConstructorTypeNode(typeParameters, parameters, type) + ? factory.createConstructorTypeNode(modifiers, typeParameters, parameters, type) : factory.createFunctionTypeNode(typeParameters, parameters, type); + if (!isConstructorType) + node.modifiers = modifiers; return withJSDoc(finishNode(node, pos), hasJSDoc); } function parseKeywordAndNoDot() { @@ -31042,6 +31415,10 @@ var ts; function parseUnionTypeOrHigher() { return parseUnionOrIntersectionType(51 /* BarToken */, parseIntersectionTypeOrHigher, factory.createUnionTypeNode); } + function nextTokenIsNewKeyword() { + nextToken(); + return token() === 102 /* NewKeyword */; + } function isStartOfFunctionTypeOrConstructorType() { if (token() === 29 /* LessThanToken */) { return true; @@ -31049,7 +31426,8 @@ var ts; if (token() === 20 /* OpenParenToken */ && lookAhead(isUnambiguouslyStartOfFunctionType)) { return true; } - return token() === 102 /* NewKeyword */; + return token() === 102 /* NewKeyword */ || + token() === 125 /* AbstractKeyword */ && lookAhead(nextTokenIsNewKeyword); } function skipParameterStart() { if (ts.isModifierKind(token())) { @@ -32139,7 +32517,7 @@ var ts; return finishNode(factory.createJsxOpeningFragment(), pos); } var tagName = parseJsxElementName(); - var typeArguments = tryParseTypeArguments(); + var typeArguments = (contextFlags & 131072 /* JavaScriptFile */) === 0 ? tryParseTypeArguments() : undefined; var attributes = parseJsxAttributes(); var node; if (token() === 31 /* GreaterThanToken */) { @@ -32365,7 +32743,8 @@ var ts; expression = parseMemberExpressionRest(pos, expression, /*allowOptionalChain*/ true); var questionDotToken = parseOptionalToken(28 /* QuestionDotToken */); // handle 'foo<()' - if (token() === 29 /* LessThanToken */ || token() === 47 /* LessThanLessThanToken */) { + // parse template arguments only in TypeScript files (not in JavaScript files). + if ((contextFlags & 131072 /* JavaScriptFile */) === 0 && (token() === 29 /* LessThanToken */ || token() === 47 /* LessThanLessThanToken */)) { // See if this is the start of a generic invocation. If so, consume it and // keep checking for postfix expressions. Otherwise, it's just a '<' that's // part of an arithmetic expression. Break out so we consume it higher in the @@ -32408,6 +32787,10 @@ var ts; return result; } function parseTypeArgumentsInExpression() { + if ((contextFlags & 131072 /* JavaScriptFile */) !== 0) { + // TypeArguments must not be parsed in JavaScript files to avoid ambiguity with binary operators. + return undefined; + } if (reScanLessThanToken() !== 29 /* LessThanToken */) { return undefined; } @@ -33889,11 +34272,8 @@ var ts; parseExpected(62 /* EqualsToken */); var moduleReference = parseModuleReference(); parseSemicolon(); - var node = factory.createImportEqualsDeclaration(decorators, modifiers, identifier, moduleReference); + var node = factory.createImportEqualsDeclaration(decorators, modifiers, isTypeOnly, identifier, moduleReference); var finished = withJSDoc(finishNode(node, pos), hasJSDoc); - if (isTypeOnly) { - parseErrorAtRange(finished, ts.Diagnostics.Only_ECMAScript_imports_may_use_import_type); - } return finished; } function parseImportClause(identifier, pos, isTypeOnly) { @@ -34435,6 +34815,7 @@ var ts; function parseTagComments(indent, initialMargin) { var comments = []; var state = 0 /* BeginningOfLine */; + var previousWhitespace = true; var margin; function pushComment(text) { if (!margin) { @@ -34460,7 +34841,8 @@ var ts; indent = 0; break; case 59 /* AtToken */: - if (state === 3 /* SavingBackticks */) { + if (state === 3 /* SavingBackticks */ || !previousWhitespace && state === 2 /* SavingComments */) { + // @ doesn't start a new tag inside ``, and inside a comment, only after whitespace comments.push(scanner.getTokenText()); break; } @@ -34517,6 +34899,7 @@ var ts; pushComment(scanner.getTokenText()); break; } + previousWhitespace = token() === 5 /* WhitespaceTrivia */; tok = nextTokenJSDoc(); } removeLeadingNewlines(comments); @@ -34581,11 +34964,11 @@ var ts; var isNameFirst = !typeExpression; skipWhitespaceOrAsterisk(); var _a = parseBracketNameInPropertyAndParamTag(), name = _a.name, isBracketed = _a.isBracketed; - skipWhitespace(); + var indentText = skipWhitespaceOrAsterisk(); if (isNameFirst) { typeExpression = tryParseTypeExpression(); } - var comment = parseTagComments(indent + scanner.getStartPos() - start); + var comment = parseTrailingTagComments(start, getNodePos(), indent, indentText); var nestedTypeLiteral = target !== 4 /* CallbackParameter */ && parseNestedTypeLiteral(typeExpression, name, target, indent); if (nestedTypeLiteral) { typeExpression = nestedTypeLiteral; @@ -34636,57 +35019,29 @@ var ts; return finishNode(factory.createJSDocSeeTag(tagName, nameExpression, comments), start, end); } function parseAuthorTag(start, tagName, indent, indentText) { - var authorInfoWithEmail = tryParse(function () { return tryParseAuthorNameAndEmail(); }); - if (!authorInfoWithEmail) { - var end_1 = getNodePos(); - return finishNode(factory.createJSDocAuthorTag(tagName, parseTrailingTagComments(start, end_1, indent, indentText)), start, end_1); - } - var comments = authorInfoWithEmail; - if (lookAhead(function () { return nextToken() !== 4 /* NewLineTrivia */; })) { - var comment = parseTagComments(indent); - if (comment) { - comments += comment; - } - } - return finishNode(factory.createJSDocAuthorTag(tagName, comments), start); + var comments = parseAuthorNameAndEmail() + (parseTrailingTagComments(start, end, indent, indentText) || ""); + return finishNode(factory.createJSDocAuthorTag(tagName, comments || undefined), start); } - function tryParseAuthorNameAndEmail() { + function parseAuthorNameAndEmail() { var comments = []; - var seenLessThan = false; - var seenGreaterThan = false; + var inEmail = false; var token = scanner.getToken(); - loop: while (true) { - switch (token) { - case 78 /* Identifier */: - case 5 /* WhitespaceTrivia */: - case 24 /* DotToken */: - case 59 /* AtToken */: - comments.push(scanner.getTokenText()); - break; - case 29 /* LessThanToken */: - if (seenLessThan || seenGreaterThan) { - return; - } - seenLessThan = true; - comments.push(scanner.getTokenText()); - break; - case 31 /* GreaterThanToken */: - if (!seenLessThan || seenGreaterThan) { - return; - } - seenGreaterThan = true; - comments.push(scanner.getTokenText()); - scanner.setTextPos(scanner.getTokenPos() + 1); - break loop; - case 4 /* NewLineTrivia */: - case 1 /* EndOfFileToken */: - break loop; + while (token !== 1 /* EndOfFileToken */ && token !== 4 /* NewLineTrivia */) { + if (token === 29 /* LessThanToken */) { + inEmail = true; + } + else if (token === 59 /* AtToken */ && !inEmail) { + break; } + else if (token === 31 /* GreaterThanToken */ && inEmail) { + comments.push(scanner.getTokenText()); + scanner.setTextPos(scanner.getTokenPos() + 1); + break; + } + comments.push(scanner.getTokenText()); token = nextTokenJSDoc(); } - if (seenLessThan && seenGreaterThan) { - return comments.length === 0 ? undefined : comments.join(""); - } + return comments.join(""); } function parseImplementsTag(start, tagName, margin, indentText) { var className = parseExpressionWithTypeArgumentsForAugments(); @@ -35857,6 +36212,30 @@ var ts; category: ts.Diagnostics.Advanced_Options, description: ts.Diagnostics.Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively, }, + { + name: "excludeDirectories", + type: "list", + element: { + name: "excludeDirectory", + type: "string", + isFilePath: true, + extraValidation: specToDiagnostic + }, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively, + }, + { + name: "excludeFiles", + type: "list", + element: { + name: "excludeFile", + type: "string", + isFilePath: true, + extraValidation: specToDiagnostic + }, + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively, + }, ]; /* @internal */ ts.commonOptionsWithBuild = [ @@ -35895,6 +36274,11 @@ var ts; description: ts.Diagnostics.Print_names_of_files_part_of_the_compilation }, { + name: "explainFiles", + type: "boolean", + category: ts.Diagnostics.Advanced_Options, + description: ts.Diagnostics.Print_names_of_files_and_the_reason_they_are_part_of_the_compilation + }, { name: "listEmittedFiles", type: "boolean", category: ts.Diagnostics.Advanced_Options, @@ -35966,7 +36350,31 @@ var ts; }, ]; /* @internal */ - ts.optionDeclarations = __spreadArrays(ts.commonOptionsWithBuild, [ + ts.targetOptionDeclaration = { + name: "target", + shortName: "t", + type: new ts.Map(ts.getEntries({ + es3: 0 /* ES3 */, + es5: 1 /* ES5 */, + es6: 2 /* ES2015 */, + es2015: 2 /* ES2015 */, + es2016: 3 /* ES2016 */, + es2017: 4 /* ES2017 */, + es2018: 5 /* ES2018 */, + es2019: 6 /* ES2019 */, + es2020: 7 /* ES2020 */, + esnext: 99 /* ESNext */, + })), + affectsSourceFile: true, + affectsModuleResolution: true, + affectsEmit: true, + paramType: ts.Diagnostics.VERSION, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Basic_Options, + description: ts.Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_ES2015_ES2016_ES2017_ES2018_ES2019_ES2020_or_ESNEXT, + }; + /* @internal */ + ts.optionDeclarations = __spreadArray(__spreadArray([], ts.commonOptionsWithBuild), [ { name: "all", type: "boolean", @@ -36024,29 +36432,7 @@ var ts; description: ts.Diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing }, // Basic - { - name: "target", - shortName: "t", - type: new ts.Map(ts.getEntries({ - es3: 0 /* ES3 */, - es5: 1 /* ES5 */, - es6: 2 /* ES2015 */, - es2015: 2 /* ES2015 */, - es2016: 3 /* ES2016 */, - es2017: 4 /* ES2017 */, - es2018: 5 /* ES2018 */, - es2019: 6 /* ES2019 */, - es2020: 7 /* ES2020 */, - esnext: 99 /* ESNext */, - })), - affectsSourceFile: true, - affectsModuleResolution: true, - affectsEmit: true, - paramType: ts.Diagnostics.VERSION, - showInSimplifiedHelpView: true, - category: ts.Diagnostics.Basic_Options, - description: ts.Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_ES2015_ES2016_ES2017_ES2018_ES2019_ES2020_or_ESNEXT, - }, + ts.targetOptionDeclaration, { name: "module", shortName: "m", @@ -36104,7 +36490,7 @@ var ts; paramType: ts.Diagnostics.KIND, showInSimplifiedHelpView: true, category: ts.Diagnostics.Basic_Options, - description: ts.Diagnostics.Specify_JSX_code_generation_Colon_preserve_react_native_or_react, + description: ts.Diagnostics.Specify_JSX_code_generation_Colon_preserve_react_native_react_react_jsx_or_react_jsxdev, }, { name: "declaration", @@ -36351,6 +36737,13 @@ var ts; category: ts.Diagnostics.Additional_Checks, description: ts.Diagnostics.Include_undefined_in_index_signature_results }, + { + name: "noPropertyAccessFromIndexSignature", + type: "boolean", + showInSimplifiedHelpView: false, + category: ts.Diagnostics.Additional_Checks, + description: ts.Diagnostics.Require_undeclared_properties_from_index_signatures_to_use_element_accesses + }, // Module Resolution { name: "moduleResolution", @@ -36775,7 +37168,7 @@ var ts; return ts.hasProperty(option, "transpileOptionValue"); }); /* @internal */ - ts.buildOpts = __spreadArrays(ts.commonOptionsWithBuild, [ + ts.buildOpts = __spreadArray(__spreadArray([], ts.commonOptionsWithBuild), [ { name: "verbose", shortName: "v", @@ -36906,9 +37299,9 @@ var ts; var values = value.split(","); switch (opt.element.type) { case "number": - return ts.map(values, parseInt); + return ts.mapDefined(values, function (v) { return validateJsonOptionValue(opt.element, parseInt(v), errors); }); case "string": - return ts.map(values, function (v) { return v || ""; }); + return ts.mapDefined(values, function (v) { return validateJsonOptionValue(opt.element, v || "", errors); }); default: return ts.mapDefined(values, function (v) { return parseCustomTypeOption(opt.element, v, errors); }); } @@ -37010,7 +37403,7 @@ var ts; } else if (opt.type === "boolean") { if (optValue === "false") { - options[opt.name] = false; + options[opt.name] = validateJsonOptionValue(opt, /*value*/ false, errors); i++; } else { @@ -37033,20 +37426,20 @@ var ts; if (args[i] !== "null") { switch (opt.type) { case "number": - options[opt.name] = parseInt(args[i]); + options[opt.name] = validateJsonOptionValue(opt, parseInt(args[i]), errors); i++; break; case "boolean": // boolean flag has optional value true, false, others var optValue = args[i]; - options[opt.name] = optValue !== "false"; + options[opt.name] = validateJsonOptionValue(opt, optValue !== "false", errors); // consume next argument as boolean flag value if (optValue === "false" || optValue === "true") { i++; } break; case "string": - options[opt.name] = args[i] || ""; + options[opt.name] = validateJsonOptionValue(opt, args[i] || "", errors); i++; break; case "list": @@ -37392,22 +37785,24 @@ var ts; } function convertArrayLiteralExpressionToJson(elements, elementOption) { if (!returnValue) { - return elements.forEach(function (element) { return convertPropertyValueToJson(element, elementOption); }); + elements.forEach(function (element) { return convertPropertyValueToJson(element, elementOption); }); + return undefined; } // Filter out invalid values return ts.filter(elements.map(function (element) { return convertPropertyValueToJson(element, elementOption); }), function (v) { return v !== undefined; }); } function convertPropertyValueToJson(valueExpression, option) { + var invalidReported; switch (valueExpression.kind) { case 109 /* TrueKeyword */: reportInvalidOptionValue(option && option.type !== "boolean"); - return true; + return validateValue(/*value*/ true); case 94 /* FalseKeyword */: reportInvalidOptionValue(option && option.type !== "boolean"); - return false; + return validateValue(/*value*/ false); case 103 /* NullKeyword */: reportInvalidOptionValue(option && option.name === "extends"); // "extends" is the only option we don't allow null/undefined for - return null; // eslint-disable-line no-null/no-null + return validateValue(/*value*/ null); // eslint-disable-line no-null/no-null case 10 /* StringLiteral */: if (!isDoubleQuotedString(valueExpression)) { errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.String_literal_with_double_quotes_expected)); @@ -37419,18 +37814,19 @@ var ts; // Validate custom option type if (!customOption.type.has(text.toLowerCase())) { errors.push(createDiagnosticForInvalidCustomType(customOption, function (message, arg0, arg1) { return ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, message, arg0, arg1); })); + invalidReported = true; } } - return text; + return validateValue(text); case 8 /* NumericLiteral */: reportInvalidOptionValue(option && option.type !== "number"); - return Number(valueExpression.text); + return validateValue(Number(valueExpression.text)); case 214 /* PrefixUnaryExpression */: if (valueExpression.operator !== 40 /* MinusToken */ || valueExpression.operand.kind !== 8 /* NumericLiteral */) { break; // not valid JSON syntax } reportInvalidOptionValue(option && option.type !== "number"); - return -Number(valueExpression.operand.text); + return validateValue(-Number(valueExpression.operand.text)); case 200 /* ObjectLiteralExpression */: reportInvalidOptionValue(option && option.type !== "object"); var objectLiteralExpression = valueExpression; @@ -37442,15 +37838,15 @@ var ts; // If need arises, we can modify this interface and callbacks as needed if (option) { var _a = option, elementOptions = _a.elementOptions, extraKeyDiagnostics = _a.extraKeyDiagnostics, optionName = _a.name; - return convertObjectLiteralExpressionToJson(objectLiteralExpression, elementOptions, extraKeyDiagnostics, optionName); + return validateValue(convertObjectLiteralExpressionToJson(objectLiteralExpression, elementOptions, extraKeyDiagnostics, optionName)); } else { - return convertObjectLiteralExpressionToJson(objectLiteralExpression, /* knownOptions*/ undefined, - /*extraKeyDiagnosticMessage */ undefined, /*parentOption*/ undefined); + return validateValue(convertObjectLiteralExpressionToJson(objectLiteralExpression, /* knownOptions*/ undefined, + /*extraKeyDiagnosticMessage */ undefined, /*parentOption*/ undefined)); } case 199 /* ArrayLiteralExpression */: reportInvalidOptionValue(option && option.type !== "list"); - return convertArrayLiteralExpressionToJson(valueExpression.elements, option && option.element); + return validateValue(convertArrayLiteralExpressionToJson(valueExpression.elements, option && option.element)); } // Not in expected format if (option) { @@ -37460,9 +37856,21 @@ var ts; errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal)); } return undefined; + function validateValue(value) { + var _a; + if (!invalidReported) { + var diagnostic = (_a = option === null || option === void 0 ? void 0 : option.extraValidation) === null || _a === void 0 ? void 0 : _a.call(option, value); + if (diagnostic) { + errors.push(ts.createDiagnosticForNodeInSourceFile.apply(void 0, __spreadArray([sourceFile, valueExpression], diagnostic))); + return undefined; + } + } + return value; + } function reportInvalidOptionValue(isError) { if (isError) { errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, option.name, getCompilerOptionValueTypeString(option))); + invalidReported = true; } } } @@ -37496,13 +37904,14 @@ var ts; */ /** @internal */ function convertToTSConfig(configParseResult, configFileName, host) { + var _a, _b, _c; var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames); - var files = ts.map(ts.filter(configParseResult.fileNames, (!configParseResult.configFileSpecs || !configParseResult.configFileSpecs.validatedIncludeSpecs) ? function (_) { return true; } : matchesSpecs(configFileName, configParseResult.configFileSpecs.validatedIncludeSpecs, configParseResult.configFileSpecs.validatedExcludeSpecs, host)), function (f) { return ts.getRelativePathFromFile(ts.getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), ts.getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName); }); + var files = ts.map(ts.filter(configParseResult.fileNames, !((_b = (_a = configParseResult.options.configFile) === null || _a === void 0 ? void 0 : _a.configFileSpecs) === null || _b === void 0 ? void 0 : _b.validatedIncludeSpecs) ? ts.returnTrue : matchesSpecs(configFileName, configParseResult.options.configFile.configFileSpecs.validatedIncludeSpecs, configParseResult.options.configFile.configFileSpecs.validatedExcludeSpecs, host)), function (f) { return ts.getRelativePathFromFile(ts.getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), ts.getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName); }); var optionMap = serializeCompilerOptions(configParseResult.options, { configFilePath: ts.getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames }); var watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions); - var config = __assign(__assign({ compilerOptions: __assign(__assign({}, optionMapToObject(optionMap)), { showConfig: undefined, configFile: undefined, configFilePath: undefined, help: undefined, init: undefined, listFiles: undefined, listEmittedFiles: undefined, project: undefined, build: undefined, version: undefined }), watchOptions: watchOptionMap && optionMapToObject(watchOptionMap), references: ts.map(configParseResult.projectReferences, function (r) { return (__assign(__assign({}, r), { path: r.originalPath ? r.originalPath : "", originalPath: undefined })); }), files: ts.length(files) ? files : undefined }, (configParseResult.configFileSpecs ? { - include: filterSameAsDefaultInclude(configParseResult.configFileSpecs.validatedIncludeSpecs), - exclude: configParseResult.configFileSpecs.validatedExcludeSpecs + var config = __assign(__assign({ compilerOptions: __assign(__assign({}, optionMapToObject(optionMap)), { showConfig: undefined, configFile: undefined, configFilePath: undefined, help: undefined, init: undefined, listFiles: undefined, listEmittedFiles: undefined, project: undefined, build: undefined, version: undefined }), watchOptions: watchOptionMap && optionMapToObject(watchOptionMap), references: ts.map(configParseResult.projectReferences, function (r) { return (__assign(__assign({}, r), { path: r.originalPath ? r.originalPath : "", originalPath: undefined })); }), files: ts.length(files) ? files : undefined }, (((_c = configParseResult.options.configFile) === null || _c === void 0 ? void 0 : _c.configFileSpecs) ? { + include: filterSameAsDefaultInclude(configParseResult.options.configFile.configFileSpecs.validatedIncludeSpecs), + exclude: configParseResult.options.configFile.configFileSpecs.validatedExcludeSpecs } : {})), { compileOnSave: !!configParseResult.compileOnSave ? true : undefined }); return config; } @@ -37524,7 +37933,7 @@ var ts; } function matchesSpecs(path, includeSpecs, excludeSpecs, host) { if (!includeSpecs) - return function (_) { return true; }; + return ts.returnTrue; var patterns = ts.getFileMatcherPatterns(path, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory()); var excludeRe = patterns.excludePattern && ts.getRegexFromPattern(patterns.excludePattern, host.useCaseSensitiveFileNames); var includeRe = patterns.includeFilePattern && ts.getRegexFromPattern(patterns.includeFilePattern, host.useCaseSensitiveFileNames); @@ -37537,7 +37946,7 @@ var ts; if (excludeRe) { return function (path) { return excludeRe.test(path); }; } - return function (_) { return true; }; + return ts.returnTrue; } function getCustomTypeMapOfCommandLineOption(optionDefinition) { if (optionDefinition.type === "string" || optionDefinition.type === "number" || optionDefinition.type === "boolean" || optionDefinition.type === "object") { @@ -37799,39 +38208,28 @@ var ts; ts.extend(existingWatchOptions, parsedConfig.watchOptions) : parsedConfig.watchOptions || existingWatchOptions; options.configFilePath = configFileName && ts.normalizeSlashes(configFileName); + var configFileSpecs = getConfigFileSpecs(); + if (sourceFile) + sourceFile.configFileSpecs = configFileSpecs; setConfigFileInOptions(options, sourceFile); - var projectReferences; - var _a = getFileNames(), fileNames = _a.fileNames, wildcardDirectories = _a.wildcardDirectories, spec = _a.spec; + var basePathForFileNames = ts.normalizePath(configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath); return { options: options, watchOptions: watchOptions, - fileNames: fileNames, - projectReferences: projectReferences, + fileNames: getFileNames(basePathForFileNames), + projectReferences: getProjectReferences(basePathForFileNames), typeAcquisition: parsedConfig.typeAcquisition || getDefaultTypeAcquisition(), raw: raw, errors: errors, - wildcardDirectories: wildcardDirectories, + // Wildcard directories (provided as part of a wildcard path) are stored in a + // file map that marks whether it was a regular wildcard match (with a `*` or `?` token), + // or a recursive directory. This information is used by filesystem watchers to monitor for + // new entries in these paths. + wildcardDirectories: getWildcardDirectories(configFileSpecs, basePathForFileNames, host.useCaseSensitiveFileNames), compileOnSave: !!raw.compileOnSave, - configFileSpecs: spec }; - function getFileNames() { + function getConfigFileSpecs() { var referencesOfRaw = getPropFromRaw("references", function (element) { return typeof element === "object"; }, "object"); - if (ts.isArray(referencesOfRaw)) { - for (var _i = 0, referencesOfRaw_1 = referencesOfRaw; _i < referencesOfRaw_1.length; _i++) { - var ref = referencesOfRaw_1[_i]; - if (typeof ref.path !== "string") { - createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "reference.path", "string"); - } - else { - (projectReferences || (projectReferences = [])).push({ - path: ts.getNormalizedAbsolutePath(ref.path, basePath), - originalPath: ref.path, - prepend: ref.prepend, - circular: ref.circular - }); - } - } - } var filesSpecs = toPropValue(getSpecsFromRaw("files")); if (filesSpecs) { var hasZeroOrNoReferences = referencesOfRaw === "no-prop" || ts.isArray(referencesOfRaw) && referencesOfRaw.length === 0; @@ -37864,11 +38262,52 @@ var ts; if (filesSpecs === undefined && includeSpecs === undefined) { includeSpecs = ["**/*"]; } - var result = matchFileNames(filesSpecs, includeSpecs, excludeSpecs, configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath, options, host, errors, extraFileExtensions, sourceFile); - if (shouldReportNoInputFiles(result, canJsonReportNoInputFiles(raw), resolutionStack)) { - errors.push(getErrorForNoInputFiles(result.spec, configFileName)); + var validatedIncludeSpecs, validatedExcludeSpecs; + // The exclude spec list is converted into a regular expression, which allows us to quickly + // test whether a file or directory should be excluded before recursively traversing the + // file system. + if (includeSpecs) { + validatedIncludeSpecs = validateSpecs(includeSpecs, errors, /*disallowTrailingRecursion*/ true, sourceFile, "include"); } - return result; + if (excludeSpecs) { + validatedExcludeSpecs = validateSpecs(excludeSpecs, errors, /*disallowTrailingRecursion*/ false, sourceFile, "exclude"); + } + return { + filesSpecs: filesSpecs, + includeSpecs: includeSpecs, + excludeSpecs: excludeSpecs, + validatedFilesSpec: ts.filter(filesSpecs, ts.isString), + validatedIncludeSpecs: validatedIncludeSpecs, + validatedExcludeSpecs: validatedExcludeSpecs, + }; + } + function getFileNames(basePath) { + var fileNames = getFileNamesFromConfigSpecs(configFileSpecs, basePath, options, host, extraFileExtensions); + if (shouldReportNoInputFiles(fileNames, canJsonReportNoInputFiles(raw), resolutionStack)) { + errors.push(getErrorForNoInputFiles(configFileSpecs, configFileName)); + } + return fileNames; + } + function getProjectReferences(basePath) { + var projectReferences; + var referencesOfRaw = getPropFromRaw("references", function (element) { return typeof element === "object"; }, "object"); + if (ts.isArray(referencesOfRaw)) { + for (var _i = 0, referencesOfRaw_1 = referencesOfRaw; _i < referencesOfRaw_1.length; _i++) { + var ref = referencesOfRaw_1[_i]; + if (typeof ref.path !== "string") { + createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "reference.path", "string"); + } + else { + (projectReferences || (projectReferences = [])).push({ + path: ts.getNormalizedAbsolutePath(ref.path, basePath), + originalPath: ref.path, + prepend: ref.prepend, + circular: ref.circular + }); + } + } + } + return projectReferences; } function toPropValue(specResult) { return ts.isArray(specResult) ? specResult : undefined; @@ -37905,8 +38344,8 @@ var ts; var includeSpecs = _a.includeSpecs, excludeSpecs = _a.excludeSpecs; return ts.createCompilerDiagnostic(ts.Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2, configFileName || "tsconfig.json", JSON.stringify(includeSpecs || []), JSON.stringify(excludeSpecs || [])); } - function shouldReportNoInputFiles(result, canJsonReportNoInutFiles, resolutionStack) { - return result.fileNames.length === 0 && canJsonReportNoInutFiles && (!resolutionStack || resolutionStack.length === 0); + function shouldReportNoInputFiles(fileNames, canJsonReportNoInutFiles, resolutionStack) { + return fileNames.length === 0 && canJsonReportNoInutFiles && (!resolutionStack || resolutionStack.length === 0); } /*@internal*/ function canJsonReportNoInputFiles(raw) { @@ -37914,9 +38353,9 @@ var ts; } ts.canJsonReportNoInputFiles = canJsonReportNoInputFiles; /*@internal*/ - function updateErrorForNoInputFiles(result, configFileName, configFileSpecs, configParseDiagnostics, canJsonReportNoInutFiles) { + function updateErrorForNoInputFiles(fileNames, configFileName, configFileSpecs, configParseDiagnostics, canJsonReportNoInutFiles) { var existingErrors = configParseDiagnostics.length; - if (shouldReportNoInputFiles(result, canJsonReportNoInutFiles)) { + if (shouldReportNoInputFiles(fileNames, canJsonReportNoInutFiles)) { configParseDiagnostics.push(getErrorForNoInputFiles(configFileSpecs, configFileName)); } else { @@ -37937,7 +38376,7 @@ var ts; basePath = ts.normalizeSlashes(basePath); var resolvedPath = ts.getNormalizedAbsolutePath(configFileName || "", basePath); if (resolutionStack.indexOf(resolvedPath) >= 0) { - errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0, __spreadArrays(resolutionStack, [resolvedPath]).join(" -> "))); + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0, __spreadArray(__spreadArray([], resolutionStack), [resolvedPath]).join(" -> "))); return { raw: json || convertToObject(sourceFile, errors) }; } var ownConfig = json ? @@ -37953,14 +38392,14 @@ var ts; if (ownConfig.extendedConfigPath) { // copy the resolution stack so it is never reused between branches in potential diamond-problem scenarios. resolutionStack = resolutionStack.concat([resolvedPath]); - var extendedConfig = getExtendedConfig(sourceFile, ownConfig.extendedConfigPath, host, basePath, resolutionStack, errors, extendedConfigCache); + var extendedConfig = getExtendedConfig(sourceFile, ownConfig.extendedConfigPath, host, resolutionStack, errors, extendedConfigCache); if (extendedConfig && isSuccessfulParsedTsconfig(extendedConfig)) { var baseRaw_1 = extendedConfig.raw; var raw_1 = ownConfig.raw; + var relativeDifference_1; var setPropertyInRawIfNotUndefined = function (propertyName) { - var value = raw_1[propertyName] || baseRaw_1[propertyName]; - if (value) { - raw_1[propertyName] = value; + if (!raw_1[propertyName] && baseRaw_1[propertyName]) { + raw_1[propertyName] = ts.map(baseRaw_1[propertyName], function (path) { return ts.isRootedDiskPath(path) ? path : ts.combinePaths(relativeDifference_1 || (relativeDifference_1 = ts.convertToRelativePath(ts.getDirectoryPath(ownConfig.extendedConfigPath), basePath, ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames))), path); }); } }; setPropertyInRawIfNotUndefined("include"); @@ -38080,7 +38519,7 @@ var ts; errors.push(createDiagnostic(ts.Diagnostics.File_0_not_found, extendedConfig)); return undefined; } - function getExtendedConfig(sourceFile, extendedConfigPath, host, basePath, resolutionStack, errors, extendedConfigCache) { + function getExtendedConfig(sourceFile, extendedConfigPath, host, resolutionStack, errors, extendedConfigCache) { var _a; var path = host.useCaseSensitiveFileNames ? extendedConfigPath : ts.toFileNameLowerCase(extendedConfigPath); var value; @@ -38092,22 +38531,7 @@ var ts; else { extendedResult = readJsonConfigFile(extendedConfigPath, function (path) { return host.readFile(path); }); if (!extendedResult.parseDiagnostics.length) { - var extendedDirname = ts.getDirectoryPath(extendedConfigPath); - extendedConfig = parseConfig(/*json*/ undefined, extendedResult, host, extendedDirname, ts.getBaseFileName(extendedConfigPath), resolutionStack, errors, extendedConfigCache); - if (isSuccessfulParsedTsconfig(extendedConfig)) { - // Update the paths to reflect base path - var relativeDifference_1 = ts.convertToRelativePath(extendedDirname, basePath, ts.identity); - var updatePath_1 = function (path) { return ts.isRootedDiskPath(path) ? path : ts.combinePaths(relativeDifference_1, path); }; - var mapPropertiesInRawIfNotUndefined = function (propertyName) { - if (raw_2[propertyName]) { - raw_2[propertyName] = ts.map(raw_2[propertyName], updatePath_1); - } - }; - var raw_2 = extendedConfig.raw; - mapPropertiesInRawIfNotUndefined("include"); - mapPropertiesInRawIfNotUndefined("exclude"); - mapPropertiesInRawIfNotUndefined("files"); - } + extendedConfig = parseConfig(/*json*/ undefined, extendedResult, host, ts.getDirectoryPath(extendedConfigPath), ts.getBaseFileName(extendedConfigPath), resolutionStack, errors, extendedConfigCache); } if (extendedConfigCache) { extendedConfigCache.set(path, { extendedResult: extendedResult, extendedConfig: extendedConfig }); @@ -38185,6 +38609,7 @@ var ts; } return defaultOptions; } + /*@internal*/ function convertJsonOption(opt, value, basePath, errors) { if (isCompilerOptionsValue(opt, value)) { var optType = opt.type; @@ -38194,12 +38619,14 @@ var ts; else if (!ts.isString(optType)) { return convertJsonOptionOfCustomType(opt, value, errors); } - return normalizeNonListOptionValue(opt, basePath, value); + var validatedValue = validateJsonOptionValue(opt, value, errors); + return isNullOrUndefined(validatedValue) ? validatedValue : normalizeNonListOptionValue(opt, basePath, validatedValue); } else { errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt))); } } + ts.convertJsonOption = convertJsonOption; function normalizeOptionValue(option, basePath, value) { if (isNullOrUndefined(value)) return undefined; @@ -38224,13 +38651,23 @@ var ts; } return value; } + function validateJsonOptionValue(opt, value, errors) { + var _a; + if (isNullOrUndefined(value)) + return undefined; + var d = (_a = opt.extraValidation) === null || _a === void 0 ? void 0 : _a.call(opt, value); + if (!d) + return value; + errors.push(ts.createCompilerDiagnostic.apply(void 0, d)); + return undefined; + } function convertJsonOptionOfCustomType(opt, value, errors) { if (isNullOrUndefined(value)) return undefined; var key = value.toLowerCase(); var val = opt.type.get(key); if (val !== undefined) { - return val; + return validateJsonOptionValue(opt, val, errors); } else { errors.push(createCompilerDiagnosticForInvalidCustomType(opt)); @@ -38295,56 +38732,17 @@ var ts; * # a path component that contains at least one wildcard character (* or ?). */ var wildcardDirectoryPattern = /^[^*?]*(?=\/[^/]*[*?])/; - /** - * Expands an array of file specifications. - * - * @param filesSpecs The literal file names to include. - * @param includeSpecs The wildcard file specifications to include. - * @param excludeSpecs The wildcard file specifications to exclude. - * @param basePath The base path for any relative file specifications. - * @param options Compiler options. - * @param host The host used to resolve files and directories. - * @param errors An array for diagnostic reporting. - */ - function matchFileNames(filesSpecs, includeSpecs, excludeSpecs, basePath, options, host, errors, extraFileExtensions, jsonSourceFile) { - basePath = ts.normalizePath(basePath); - var validatedIncludeSpecs, validatedExcludeSpecs; - // The exclude spec list is converted into a regular expression, which allows us to quickly - // test whether a file or directory should be excluded before recursively traversing the - // file system. - if (includeSpecs) { - validatedIncludeSpecs = validateSpecs(includeSpecs, errors, /*allowTrailingRecursion*/ false, jsonSourceFile, "include"); - } - if (excludeSpecs) { - validatedExcludeSpecs = validateSpecs(excludeSpecs, errors, /*allowTrailingRecursion*/ true, jsonSourceFile, "exclude"); - } - // Wildcard directories (provided as part of a wildcard path) are stored in a - // file map that marks whether it was a regular wildcard match (with a `*` or `?` token), - // or a recursive directory. This information is used by filesystem watchers to monitor for - // new entries in these paths. - var wildcardDirectories = getWildcardDirectories(validatedIncludeSpecs, validatedExcludeSpecs, basePath, host.useCaseSensitiveFileNames); - var spec = { - filesSpecs: filesSpecs, - includeSpecs: includeSpecs, - excludeSpecs: excludeSpecs, - validatedFilesSpec: ts.filter(filesSpecs, ts.isString), - validatedIncludeSpecs: validatedIncludeSpecs, - validatedExcludeSpecs: validatedExcludeSpecs, - wildcardDirectories: wildcardDirectories - }; - return getFileNamesFromConfigSpecs(spec, basePath, options, host, extraFileExtensions); - } /** * Gets the file names from the provided config file specs that contain, files, include, exclude and * other properties needed to resolve the file names - * @param spec The config file specs extracted with file names to include, wildcards to include/exclude and other details + * @param configFileSpecs The config file specs extracted with file names to include, wildcards to include/exclude and other details * @param basePath The base path for any relative file specifications. * @param options Compiler options. * @param host The host used to resolve files and directories. * @param extraFileExtensions optionaly file extra file extension information from host */ /* @internal */ - function getFileNamesFromConfigSpecs(spec, basePath, options, host, extraFileExtensions) { + function getFileNamesFromConfigSpecs(configFileSpecs, basePath, options, host, extraFileExtensions) { if (extraFileExtensions === void 0) { extraFileExtensions = ts.emptyArray; } basePath = ts.normalizePath(basePath); var keyMapper = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames); @@ -38360,7 +38758,7 @@ var ts; // file map with a possibly case insensitive key. We use this map to store paths matched // via wildcard of *.json kind var wildCardJsonFileMap = new ts.Map(); - var validatedFilesSpec = spec.validatedFilesSpec, validatedIncludeSpecs = spec.validatedIncludeSpecs, validatedExcludeSpecs = spec.validatedExcludeSpecs, wildcardDirectories = spec.wildcardDirectories; + var validatedFilesSpec = configFileSpecs.validatedFilesSpec, validatedIncludeSpecs = configFileSpecs.validatedIncludeSpecs, validatedExcludeSpecs = configFileSpecs.validatedExcludeSpecs; // Rather than requery this for each file and filespec, we query the supported extensions // once and store it on the expansion context. var supportedExtensions = ts.getSupportedExtensions(options, extraFileExtensions); @@ -38419,11 +38817,7 @@ var ts; } var literalFiles = ts.arrayFrom(literalFileMap.values()); var wildcardFiles = ts.arrayFrom(wildcardFileMap.values()); - return { - fileNames: literalFiles.concat(wildcardFiles, ts.arrayFrom(wildCardJsonFileMap.values())), - wildcardDirectories: wildcardDirectories, - spec: spec - }; + return literalFiles.concat(wildcardFiles, ts.arrayFrom(wildCardJsonFileMap.values())); } ts.getFileNamesFromConfigSpecs = getFileNamesFromConfigSpecs; /* @internal */ @@ -38440,7 +38834,16 @@ var ts; return false; } } - var excludePattern = ts.getRegularExpressionForWildcard(validatedExcludeSpecs, ts.combinePaths(ts.normalizePath(currentDirectory), basePath), "exclude"); + return matchesExcludeWorker(pathToCheck, validatedExcludeSpecs, useCaseSensitiveFileNames, currentDirectory, basePath); + } + ts.isExcludedFile = isExcludedFile; + /* @internal */ + function matchesExclude(pathToCheck, excludeSpecs, useCaseSensitiveFileNames, currentDirectory) { + return matchesExcludeWorker(pathToCheck, ts.filter(excludeSpecs, function (spec) { return !invalidDotDotAfterRecursiveWildcardPattern.test(spec); }), useCaseSensitiveFileNames, currentDirectory); + } + ts.matchesExclude = matchesExclude; + function matchesExcludeWorker(pathToCheck, excludeSpecs, useCaseSensitiveFileNames, currentDirectory, basePath) { + var excludePattern = ts.getRegularExpressionForWildcard(excludeSpecs, ts.combinePaths(ts.normalizePath(currentDirectory), basePath), "exclude"); var excludeRegex = excludePattern && ts.getRegexFromPattern(excludePattern, useCaseSensitiveFileNames); if (!excludeRegex) return false; @@ -38448,14 +38851,13 @@ var ts; return true; return !ts.hasExtension(pathToCheck) && excludeRegex.test(ts.ensureTrailingDirectorySeparator(pathToCheck)); } - ts.isExcludedFile = isExcludedFile; - function validateSpecs(specs, errors, allowTrailingRecursion, jsonSourceFile, specKey) { + function validateSpecs(specs, errors, disallowTrailingRecursion, jsonSourceFile, specKey) { return specs.filter(function (spec) { if (!ts.isString(spec)) return false; - var diag = specToDiagnostic(spec, allowTrailingRecursion); + var diag = specToDiagnostic(spec, disallowTrailingRecursion); if (diag !== undefined) { - errors.push(createDiagnostic(diag, spec)); + errors.push(createDiagnostic.apply(void 0, diag)); } return diag === undefined; }); @@ -38466,18 +38868,19 @@ var ts; ts.createCompilerDiagnostic(message, spec); } } - function specToDiagnostic(spec, allowTrailingRecursion) { - if (!allowTrailingRecursion && invalidTrailingRecursionPattern.test(spec)) { - return ts.Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0; + function specToDiagnostic(spec, disallowTrailingRecursion) { + if (disallowTrailingRecursion && invalidTrailingRecursionPattern.test(spec)) { + return [ts.Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec]; } else if (invalidDotDotAfterRecursiveWildcardPattern.test(spec)) { - return ts.Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0; + return [ts.Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec]; } } /** * Gets directories in a set of include patterns that should be watched for changes. */ - function getWildcardDirectories(include, exclude, path, useCaseSensitiveFileNames) { + function getWildcardDirectories(_a, path, useCaseSensitiveFileNames) { + var include = _a.validatedIncludeSpecs, exclude = _a.validatedExcludeSpecs; // We watch a directory recursively if it contains a wildcard anywhere in a directory segment // of the pattern: // @@ -38516,8 +38919,8 @@ var ts; // Remove any subpaths under an existing recursively watched directory. for (var key in wildcardDirectories) { if (ts.hasProperty(wildcardDirectories, key)) { - for (var _a = 0, recursiveKeys_1 = recursiveKeys; _a < recursiveKeys_1.length; _a++) { - var recursiveKey = recursiveKeys_1[_a]; + for (var _b = 0, recursiveKeys_1 = recursiveKeys; _b < recursiveKeys_1.length; _b++) { + var recursiveKey = recursiveKeys_1[_b]; if (key !== recursiveKey && ts.containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) { delete wildcardDirectories[key]; } @@ -39364,7 +39767,7 @@ var ts; ts.tryResolveJSModule = tryResolveJSModule; var jsOnlyExtensions = [Extensions.JavaScript]; var tsExtensions = [Extensions.TypeScript, Extensions.JavaScript]; - var tsPlusJsonExtensions = __spreadArrays(tsExtensions, [Extensions.Json]); + var tsPlusJsonExtensions = __spreadArray(__spreadArray([], tsExtensions), [Extensions.Json]); var tsconfigExtensions = [Extensions.TSConfig]; function tryResolveJSModuleWorker(moduleName, initialDir, host) { return nodeModuleNameResolverWorker(moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, /*cache*/ undefined, jsOnlyExtensions, /*redirectedReferences*/ undefined); @@ -39462,7 +39865,7 @@ var ts; ts.pathContainsNodeModules = pathContainsNodeModules; /** * This will be called on the successfully resolved path from `loadModuleFromFile`. - * (Not neeeded for `loadModuleFromNodeModules` as that looks up the `package.json` as part of resolution.) + * (Not needed for `loadModuleFromNodeModules` as that looks up the `package.json` as part of resolution.) * * packageDirectory is the directory of the package itself. * For `blah/node_modules/foo/index.d.ts` this is packageDirectory: "foo" @@ -39762,7 +40165,7 @@ var ts; trace(state.host, ts.Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path); } // A path mapping may have an extension, in contrast to an import, which should omit it. - var extension = ts.tryGetExtensionFromPath(candidate); + var extension = ts.tryGetExtensionFromPath(subst); if (extension !== undefined) { var path_1 = tryFile(candidate, onlyRecordFailures, state); if (path_1 !== undefined) { @@ -40051,15 +40454,14 @@ var ts; } var binder = createBinder(); function bindSourceFile(file, options) { - var tracingData = ["bind" /* Bind */, "bindSourceFile", { path: file.path }]; - ts.tracing.begin.apply(ts.tracing, tracingData); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("bind" /* Bind */, "bindSourceFile", { path: file.path }, /*separateBeginAndEnd*/ true); ts.performance.mark("beforeBind"); ts.perfLogger.logStartBindFile("" + file.fileName); binder(file, options); ts.perfLogger.logStopBindFile(); ts.performance.mark("afterBind"); ts.performance.measure("Bind", "beforeBind", "afterBind"); - ts.tracing.end.apply(ts.tracing, tracingData); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); } ts.bindSourceFile = bindSourceFile; function createBinder() { @@ -40368,7 +40770,7 @@ var ts; } }); var diag = createDiagnosticForNode(declarationName_1, message_1, messageNeedsName_1 ? getDisplayName(node) : undefined); - file.bindDiagnostics.push(ts.addRelatedInfo.apply(void 0, __spreadArrays([diag], relatedInformation_1))); + file.bindDiagnostics.push(ts.addRelatedInfo.apply(void 0, __spreadArray([diag], relatedInformation_1))); symbol = createSymbol(0 /* None */, name); } } @@ -40507,7 +40909,7 @@ var ts; } // We create a return control flow graph for IIFEs and constructors. For constructors // we use the return control flow graph in strict property initialization checks. - currentReturnTarget = isIIFE || node.kind === 166 /* Constructor */ || (ts.isInJSFile && (node.kind === 251 /* FunctionDeclaration */ || node.kind === 208 /* FunctionExpression */)) ? createBranchLabel() : undefined; + currentReturnTarget = isIIFE || node.kind === 166 /* Constructor */ || (ts.isInJSFile(node) && (node.kind === 251 /* FunctionDeclaration */ || node.kind === 208 /* FunctionExpression */)) ? createBranchLabel() : undefined; currentExceptionTarget = undefined; currentBreakTarget = undefined; currentContinueTarget = undefined; @@ -40528,7 +40930,7 @@ var ts; if (currentReturnTarget) { addAntecedent(currentReturnTarget, currentFlow); currentFlow = finishFlowLabel(currentReturnTarget); - if (node.kind === 166 /* Constructor */ || (ts.isInJSFile && (node.kind === 251 /* FunctionDeclaration */ || node.kind === 208 /* FunctionExpression */))) { + if (node.kind === 166 /* Constructor */ || (ts.isInJSFile(node) && (node.kind === 251 /* FunctionDeclaration */ || node.kind === 208 /* FunctionExpression */))) { node.returnFlowNode = currentFlow; } } @@ -41869,8 +42271,8 @@ var ts; for (var _i = 0, delayedTypeAliases_1 = delayedTypeAliases; _i < delayedTypeAliases_1.length; _i++) { var typeAlias = delayedTypeAliases_1[_i]; var host = ts.getJSDocHost(typeAlias); - container = ts.findAncestor(host.parent, function (n) { return !!(getContainerFlags(n) & 1 /* IsContainer */); }) || file; - blockScopeContainer = ts.getEnclosingBlockScopeContainer(host) || file; + container = (host && ts.findAncestor(host.parent, function (n) { return !!(getContainerFlags(n) & 1 /* IsContainer */); })) || file; + blockScopeContainer = (host && ts.getEnclosingBlockScopeContainer(host)) || file; currentFlow = initFlowNode({ flags: 2 /* Start */ }); parent = typeAlias; bind(typeAlias.typeExpression); @@ -42218,6 +42620,11 @@ var ts; node.flowNode = currentFlow; } return checkContextualIdentifier(node); + case 157 /* QualifiedName */: + if (currentFlow && parent.kind === 176 /* TypeQuery */) { + node.flowNode = currentFlow; + } + break; case 105 /* SuperKeyword */: node.flowNode = currentFlow; break; @@ -43045,7 +43452,7 @@ var ts; // reachability checks function shouldReportErrorOnModuleDeclaration(node) { var instanceState = getModuleInstanceState(node); - return instanceState === 1 /* Instantiated */ || (instanceState === 2 /* ConstEnumOnly */ && !!options.preserveConstEnums); + return instanceState === 1 /* Instantiated */ || (instanceState === 2 /* ConstEnumOnly */ && ts.shouldPreserveConstEnums(options)); } function checkUnreachable(node) { if (!(currentFlow.flags & 1 /* Unreachable */)) { @@ -43500,7 +43907,8 @@ var ts; IntersectionState[IntersectionState["Source"] = 1] = "Source"; IntersectionState[IntersectionState["Target"] = 2] = "Target"; IntersectionState[IntersectionState["PropertyCheck"] = 4] = "PropertyCheck"; - IntersectionState[IntersectionState["InPropertyCheck"] = 8] = "InPropertyCheck"; + IntersectionState[IntersectionState["UnionIntersectionCheck"] = 8] = "UnionIntersectionCheck"; + IntersectionState[IntersectionState["InPropertyCheck"] = 16] = "InPropertyCheck"; })(IntersectionState || (IntersectionState = {})); var MappedTypeModifiers; (function (MappedTypeModifiers) { @@ -43623,7 +44031,6 @@ var ts; var totalInstantiationCount = 0; var instantiationCount = 0; var instantiationDepth = 0; - var constraintDepth = 0; var currentNode; var typeCatalog = []; // NB: id is index + 1 var emptySymbols = ts.createSymbolTable(); @@ -43915,6 +44322,10 @@ var ts; return resolveName(location, ts.escapeLeadingUnderscores(name), meaning, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false, excludeGlobals); }, getJsxNamespace: function (n) { return ts.unescapeLeadingUnderscores(getJsxNamespace(n)); }, + getJsxFragmentFactory: function (n) { + var jsxFragmentFactory = getJsxFragmentFactoryEntity(n); + return jsxFragmentFactory && ts.unescapeLeadingUnderscores(ts.getFirstIdentifier(jsxFragmentFactory).escapedText); + }, getAccessibleSymbolChain: getAccessibleSymbolChain, getTypePredicateOfSignature: getTypePredicateOfSignature, resolveExternalModuleName: function (moduleSpecifierIn) { @@ -44323,6 +44734,25 @@ var ts; } return diagnostic; } + function addDeprecatedSuggestionWorker(declarations, diagnostic) { + var deprecatedTag = Array.isArray(declarations) ? ts.forEach(declarations, ts.getJSDocDeprecatedTag) : ts.getJSDocDeprecatedTag(declarations); + if (deprecatedTag) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(deprecatedTag, ts.Diagnostics.The_declaration_was_marked_as_deprecated_here)); + } + // We call `addRelatedInfo()` before adding the diagnostic to prevent duplicates. + suggestionDiagnostics.add(diagnostic); + return diagnostic; + } + function addDeprecatedSuggestion(location, declarations, deprecatedEntity) { + var diagnostic = ts.createDiagnosticForNode(location, ts.Diagnostics._0_is_deprecated, deprecatedEntity); + return addDeprecatedSuggestionWorker(declarations, diagnostic); + } + function addDeprecatedSuggestionWithSignature(location, declaration, deprecatedEntity, signatureString) { + var diagnostic = deprecatedEntity + ? ts.createDiagnosticForNode(location, ts.Diagnostics.The_signature_0_of_1_is_deprecated, signatureString, deprecatedEntity) + : ts.createDiagnosticForNode(location, ts.Diagnostics._0_is_deprecated, signatureString); + return addDeprecatedSuggestionWorker(declaration, diagnostic); + } function createSymbol(flags, name, checkFlags) { symbolCount++; var symbol = (new Symbol(flags | 33554432 /* Transient */, name)); @@ -45124,7 +45554,10 @@ var ts; case 324 /* JSDocCallbackTag */: case 325 /* JSDocEnumTag */: // js type aliases do not resolve names from their host, so skip past it - location = ts.getJSDocHost(location); + var root = ts.getJSDocRoot(location); + if (root) { + location = root.parent; + } break; case 160 /* Parameter */: if (lastLocation && (lastLocation === location.initializer || @@ -45195,6 +45628,10 @@ var ts; var suggestion = void 0; if (suggestedNameNotFoundMessage && suggestionCount < maximumSuggestionCount) { suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning); + var isGlobalScopeAugmentationDeclaration = suggestion && suggestion.valueDeclaration && ts.isAmbientModule(suggestion.valueDeclaration) && ts.isGlobalScopeAugmentation(suggestion.valueDeclaration); + if (isGlobalScopeAugmentationDeclaration) { + suggestion = undefined; + } if (suggestion) { var suggestionName = symbolToString(suggestion); var diagnostic = error(errorLocation, suggestedNameNotFoundMessage, diagnosticName(nameArg), suggestionName); @@ -45518,7 +45955,7 @@ var ts; } else { ts.Debug.assert(!!(result.flags & 128 /* ConstEnum */)); - if (compilerOptions.preserveConstEnums) { + if (ts.shouldPreserveConstEnums(compilerOptions)) { diagnosticMessage = error(errorLocation, ts.Diagnostics.Enum_0_used_before_its_declaration, declarationName); } } @@ -45606,7 +46043,7 @@ var ts; return resolved; } function checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved) { - if (markSymbolOfAliasDeclarationIfTypeOnly(node, /*immediateTarget*/ undefined, resolved, /*overwriteEmpty*/ false)) { + if (markSymbolOfAliasDeclarationIfTypeOnly(node, /*immediateTarget*/ undefined, resolved, /*overwriteEmpty*/ false) && !node.isTypeOnly) { var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(getSymbolOfNode(node)); var isExport = ts.typeOnlyDeclarationIsExport(typeOnlyDeclaration); var message = isExport @@ -45706,7 +46143,8 @@ var ts; if (exportStar) { var defaultExport = ts.find(exportStar.declarations, function (decl) { var _a, _b; - return !!(ts.isExportDeclaration(decl) && decl.moduleSpecifier && ((_b = (_a = resolveExternalModuleName(decl, decl.moduleSpecifier)) === null || _a === void 0 ? void 0 : _a.exports) === null || _b === void 0 ? void 0 : _b.has("default" /* Default */))); + return !!(ts.isExportDeclaration(decl) && decl.moduleSpecifier && + ((_b = (_a = resolveExternalModuleName(decl, decl.moduleSpecifier)) === null || _a === void 0 ? void 0 : _a.exports) === null || _b === void 0 ? void 0 : _b.has("default" /* Default */))); }); if (defaultExport) { ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(defaultExport, ts.Diagnostics.export_Asterisk_does_not_re_export_a_default)); @@ -45799,7 +46237,7 @@ var ts; var symbolFromVariable = void 0; // First check if module was specified with "export=". If so, get the member from the resolved type if (moduleSymbol && moduleSymbol.exports && moduleSymbol.exports.get("export=" /* ExportEquals */)) { - symbolFromVariable = getPropertyOfType(getTypeOfSymbol(targetSymbol), name.escapedText); + symbolFromVariable = getPropertyOfType(getTypeOfSymbol(targetSymbol), name.escapedText, /*skipObjectFunctionPropertyAugment*/ true); } else { symbolFromVariable = getPropertyOfVariable(targetSymbol, name.escapedText); @@ -45854,7 +46292,7 @@ var ts; var exportedSymbol = exports ? ts.find(symbolsToArray(exports), function (symbol) { return !!getSymbolIfSameReference(symbol, localSymbol); }) : undefined; var diagnostic = exportedSymbol ? error(name, ts.Diagnostics.Module_0_declares_1_locally_but_it_is_exported_as_2, moduleName, declarationName, symbolToString(exportedSymbol)) : error(name, ts.Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported, moduleName, declarationName); - ts.addRelatedInfo.apply(void 0, __spreadArrays([diagnostic], ts.map(localSymbol.declarations, function (decl, index) { + ts.addRelatedInfo.apply(void 0, __spreadArray([diagnostic], ts.map(localSymbol.declarations, function (decl, index) { return ts.createDiagnosticForNode(decl, index === 0 ? ts.Diagnostics._0_is_declared_here : ts.Diagnostics.and_here, declarationName); }))); } @@ -45888,7 +46326,7 @@ var ts; var resolved = getExternalModuleMember(root, commonJSPropertyAccess || node, dontResolveAlias); var name = node.propertyName || node.name; if (commonJSPropertyAccess && resolved && ts.isIdentifier(name)) { - return getPropertyOfType(getTypeOfSymbol(resolved), name.escapedText); + return resolveSymbol(getPropertyOfType(getTypeOfSymbol(resolved), name.escapedText), dontResolveAlias); } markSymbolOfAliasDeclarationIfTypeOnly(node, /*immediateTarget*/ undefined, resolved, /*overwriteEmpty*/ false); return resolved; @@ -46216,7 +46654,8 @@ var ts; return; } var host = ts.getJSDocHost(node); - if (ts.isExpressionStatement(host) && + if (host && + ts.isExpressionStatement(host) && ts.isBinaryExpression(host.expression) && ts.getAssignmentDeclarationKind(host.expression) === 3 /* PrototypeProperty */) { // X.prototype.m = /** @param {K} p */ function () { } <-- look for K on X's declaration @@ -46225,7 +46664,7 @@ var ts; return getDeclarationOfJSPrototypeContainer(symbol); } } - if ((ts.isObjectLiteralMethod(host) || ts.isPropertyAssignment(host)) && + if (host && (ts.isObjectLiteralMethod(host) || ts.isPropertyAssignment(host)) && ts.isBinaryExpression(host.parent.parent) && ts.getAssignmentDeclarationKind(host.parent.parent) === 6 /* Prototype */) { // X.prototype = { /** @param {K} p */m() { } } <-- look for K on X's declaration @@ -46353,7 +46792,17 @@ var ts; var tsExtension = ts.tryExtractTSExtension(moduleReference); if (tsExtension) { var diag = ts.Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead; - error(errorNode, diag, tsExtension, ts.removeExtension(moduleReference, tsExtension)); + var importSourceWithoutExtension = ts.removeExtension(moduleReference, tsExtension); + var replacedImportSource = importSourceWithoutExtension; + /** + * Direct users to import source with .js extension if outputting an ES module. + * @see https://github.com/microsoft/TypeScript/issues/42151 + */ + var moduleKind_1 = ts.getEmitModuleKind(compilerOptions); + if (moduleKind_1 >= ts.ModuleKind.ES2015) { + replacedImportSource += ".js"; + } + error(errorNode, diag, tsExtension, replacedImportSource); } else if (!compilerOptions.resolveJsonModule && ts.fileExtensionIs(moduleReference, ".json" /* Json */) && @@ -46731,6 +47180,9 @@ var ts; typeCatalog.push(result); return result; } + function createOriginType(flags) { + return new Type(checker, flags); + } function createIntrinsicType(kind, intrinsicName, objectFlags) { if (objectFlags === void 0) { objectFlags = 0; } var type = createType(kind); @@ -46786,17 +47238,34 @@ var ts; return result || ts.emptyArray; } function setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo) { - type.members = members; - type.properties = members === emptySymbols ? ts.emptyArray : getNamedMembers(members); - type.callSignatures = callSignatures; - type.constructSignatures = constructSignatures; - type.stringIndexInfo = stringIndexInfo; - type.numberIndexInfo = numberIndexInfo; - return type; + var resolved = type; + resolved.members = members; + resolved.properties = ts.emptyArray; + resolved.callSignatures = callSignatures; + resolved.constructSignatures = constructSignatures; + resolved.stringIndexInfo = stringIndexInfo; + resolved.numberIndexInfo = numberIndexInfo; + // This can loop back to getPropertyOfType() which would crash if `callSignatures` & `constructSignatures` are not initialized. + if (members !== emptySymbols) + resolved.properties = getNamedMembers(members); + return resolved; } function createAnonymousType(symbol, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo) { return setStructuredTypeMembers(createObjectType(16 /* Anonymous */, symbol), members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo); } + function getResolvedTypeWithoutAbstractConstructSignatures(type) { + if (type.constructSignatures.length === 0) + return type; + if (type.objectTypeWithoutAbstractConstructSignatures) + return type.objectTypeWithoutAbstractConstructSignatures; + var constructSignatures = ts.filter(type.constructSignatures, function (signature) { return !(signature.flags & 4 /* Abstract */); }); + if (type.constructSignatures === constructSignatures) + return type; + var typeCopy = createAnonymousType(type.symbol, type.members, type.callSignatures, ts.some(constructSignatures) ? constructSignatures : ts.emptyArray, type.stringIndexInfo, type.numberIndexInfo); + type.objectTypeWithoutAbstractConstructSignatures = typeCopy; + typeCopy.objectTypeWithoutAbstractConstructSignatures = typeCopy; + return typeCopy; + } function forEachSymbolTableInScope(enclosingDeclaration, callback) { var result; var _loop_8 = function (location) { @@ -47080,7 +47549,8 @@ var ts; return { accessibility: 2 /* CannotBeNamed */, errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning), - errorModuleName: symbolToString(symbolExternalModule) + errorModuleName: symbolToString(symbolExternalModule), + errorNode: ts.isInJSFile(enclosingDeclaration) ? enclosingDeclaration : undefined, }; } } @@ -47315,6 +47785,7 @@ var ts; getProjectReferenceRedirect: function (fileName) { return host.getProjectReferenceRedirect(fileName); }, isSourceOfProjectReferenceRedirect: function (fileName) { return host.isSourceOfProjectReferenceRedirect(fileName); }, fileExists: function (fileName) { return host.fileExists(fileName); }, + getFileIncludeReasons: function () { return host.getFileIncludeReasons(); }, } : undefined }, encounteredError: false, visitedTypes: undefined, @@ -47491,6 +47962,9 @@ var ts; ? symbolToTypeNode(type.symbol, context, 788968 /* Type */) : ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("?"), /*typeArguments*/ undefined); } + if (type.flags & 1048576 /* Union */ && type.origin) { + type = type.origin; + } if (type.flags & (1048576 /* Union */ | 2097152 /* Intersection */)) { var types = type.flags & 1048576 /* Union */ ? formatUnionTypes(type.types) : type.types; if (ts.length(types) === 1) { @@ -47498,8 +47972,7 @@ var ts; } var typeNodes = mapToTypeNodes(types, context, /*isBareList*/ true); if (typeNodes && typeNodes.length > 0) { - var unionOrIntersectionTypeNode = type.flags & 1048576 /* Union */ ? ts.factory.createUnionTypeNode(typeNodes) : ts.factory.createIntersectionTypeNode(typeNodes); - return unionOrIntersectionTypeNode; + return type.flags & 1048576 /* Union */ ? ts.factory.createUnionTypeNode(typeNodes) : ts.factory.createIntersectionTypeNode(typeNodes); } else { if (!context.encounteredError && !(context.flags & 262144 /* AllowEmptyUnionOrIntersection */)) { @@ -47688,13 +48161,36 @@ var ts; return signatureNode; } } + var abstractSignatures = ts.filter(resolved.constructSignatures, function (signature) { return !!(signature.flags & 4 /* Abstract */); }); + if (ts.some(abstractSignatures)) { + var types = ts.map(abstractSignatures, getOrCreateTypeFromSignature); + // count the number of type elements excluding abstract constructors + var typeElementCount = resolved.callSignatures.length + + (resolved.constructSignatures.length - abstractSignatures.length) + + (resolved.stringIndexInfo ? 1 : 0) + + (resolved.numberIndexInfo ? 1 : 0) + + // exclude `prototype` when writing a class expression as a type literal, as per + // the logic in `createTypeNodesFromResolvedType`. + (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? + ts.countWhere(resolved.properties, function (p) { return !(p.flags & 4194304 /* Prototype */); }) : + ts.length(resolved.properties)); + // don't include an empty object literal if there were no other static-side + // properties to write, i.e. `abstract class C { }` becomes `abstract new () => {}` + // and not `(abstract new () => {}) & {}` + if (typeElementCount) { + // create a copy of the object type without any abstract construct signatures. + types.push(getResolvedTypeWithoutAbstractConstructSignatures(resolved)); + } + return typeToTypeNodeHelper(getIntersectionType(types), context); + } var savedFlags = context.flags; context.flags |= 4194304 /* InObjectTypeLiteral */; var members = createTypeNodesFromResolvedType(resolved); context.flags = savedFlags; var typeLiteralNode = ts.factory.createTypeLiteralNode(members); context.approximateLength += 2; - return ts.setEmitFlags(typeLiteralNode, (context.flags & 1024 /* MultilineObjectLiterals */) ? 0 : 1 /* SingleLine */); + ts.setEmitFlags(typeLiteralNode, (context.flags & 1024 /* MultilineObjectLiterals */) ? 0 : 1 /* SingleLine */); + return typeLiteralNode; } function typeReferenceToTypeNode(type) { var typeArguments = getTypeArguments(type); @@ -47845,6 +48341,8 @@ var ts; } for (var _b = 0, _c = resolvedType.constructSignatures; _b < _c.length; _b++) { var signature = _c[_b]; + if (signature.flags & 4 /* Abstract */) + continue; typeElements.push(signatureToSignatureDeclarationHelper(signature, 170 /* ConstructSignature */, context)); } if (resolvedType.stringIndexInfo) { @@ -47899,7 +48397,7 @@ var ts; anyType : getTypeOfSymbol(propertySymbol); var saveEnclosingDeclaration = context.enclosingDeclaration; context.enclosingDeclaration = undefined; - if (context.tracker.trackSymbol && ts.getCheckFlags(propertySymbol) & 4096 /* Late */) { + if (context.tracker.trackSymbol && ts.getCheckFlags(propertySymbol) & 4096 /* Late */ && isLateBoundName(propertySymbol.escapedName)) { var decl = ts.first(propertySymbol.declarations); if (hasLateBindableName(decl)) { if (ts.isBinaryExpression(decl)) { @@ -48089,21 +48587,26 @@ var ts; returnTypeNode = ts.factory.createKeywordTypeNode(128 /* AnyKeyword */); } } + var modifiers = options === null || options === void 0 ? void 0 : options.modifiers; + if ((kind === 175 /* ConstructorType */) && signature.flags & 4 /* Abstract */) { + var flags = ts.modifiersToFlags(modifiers); + modifiers = ts.factory.createModifiersFromModifierFlags(flags | 128 /* Abstract */); + } context.approximateLength += 3; // Usually a signature contributes a few more characters than this, but 3 is the minimum var node = kind === 169 /* CallSignature */ ? ts.factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 170 /* ConstructSignature */ ? ts.factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : - kind === 164 /* MethodSignature */ ? ts.factory.createMethodSignature(options === null || options === void 0 ? void 0 : options.modifiers, (_a = options === null || options === void 0 ? void 0 : options.name) !== null && _a !== void 0 ? _a : ts.factory.createIdentifier(""), options === null || options === void 0 ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : - kind === 165 /* MethodDeclaration */ ? ts.factory.createMethodDeclaration(/*decorators*/ undefined, options === null || options === void 0 ? void 0 : options.modifiers, /*asteriskToken*/ undefined, (_b = options === null || options === void 0 ? void 0 : options.name) !== null && _b !== void 0 ? _b : ts.factory.createIdentifier(""), /*questionToken*/ undefined, typeParameters, parameters, returnTypeNode, /*body*/ undefined) : - kind === 166 /* Constructor */ ? ts.factory.createConstructorDeclaration(/*decorators*/ undefined, options === null || options === void 0 ? void 0 : options.modifiers, parameters, /*body*/ undefined) : - kind === 167 /* GetAccessor */ ? ts.factory.createGetAccessorDeclaration(/*decorators*/ undefined, options === null || options === void 0 ? void 0 : options.modifiers, (_c = options === null || options === void 0 ? void 0 : options.name) !== null && _c !== void 0 ? _c : ts.factory.createIdentifier(""), parameters, returnTypeNode, /*body*/ undefined) : - kind === 168 /* SetAccessor */ ? ts.factory.createSetAccessorDeclaration(/*decorators*/ undefined, options === null || options === void 0 ? void 0 : options.modifiers, (_d = options === null || options === void 0 ? void 0 : options.name) !== null && _d !== void 0 ? _d : ts.factory.createIdentifier(""), parameters, /*body*/ undefined) : - kind === 171 /* IndexSignature */ ? ts.factory.createIndexSignature(/*decorators*/ undefined, options === null || options === void 0 ? void 0 : options.modifiers, parameters, returnTypeNode) : + kind === 164 /* MethodSignature */ ? ts.factory.createMethodSignature(modifiers, (_a = options === null || options === void 0 ? void 0 : options.name) !== null && _a !== void 0 ? _a : ts.factory.createIdentifier(""), options === null || options === void 0 ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : + kind === 165 /* MethodDeclaration */ ? ts.factory.createMethodDeclaration(/*decorators*/ undefined, modifiers, /*asteriskToken*/ undefined, (_b = options === null || options === void 0 ? void 0 : options.name) !== null && _b !== void 0 ? _b : ts.factory.createIdentifier(""), /*questionToken*/ undefined, typeParameters, parameters, returnTypeNode, /*body*/ undefined) : + kind === 166 /* Constructor */ ? ts.factory.createConstructorDeclaration(/*decorators*/ undefined, modifiers, parameters, /*body*/ undefined) : + kind === 167 /* GetAccessor */ ? ts.factory.createGetAccessorDeclaration(/*decorators*/ undefined, modifiers, (_c = options === null || options === void 0 ? void 0 : options.name) !== null && _c !== void 0 ? _c : ts.factory.createIdentifier(""), parameters, returnTypeNode, /*body*/ undefined) : + kind === 168 /* SetAccessor */ ? ts.factory.createSetAccessorDeclaration(/*decorators*/ undefined, modifiers, (_d = options === null || options === void 0 ? void 0 : options.name) !== null && _d !== void 0 ? _d : ts.factory.createIdentifier(""), parameters, /*body*/ undefined) : + kind === 171 /* IndexSignature */ ? ts.factory.createIndexSignature(/*decorators*/ undefined, modifiers, parameters, returnTypeNode) : kind === 308 /* JSDocFunctionType */ ? ts.factory.createJSDocFunctionType(parameters, returnTypeNode) : kind === 174 /* FunctionType */ ? ts.factory.createFunctionTypeNode(typeParameters, parameters, returnTypeNode !== null && returnTypeNode !== void 0 ? returnTypeNode : ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(""))) : - kind === 175 /* ConstructorType */ ? ts.factory.createConstructorTypeNode(typeParameters, parameters, returnTypeNode !== null && returnTypeNode !== void 0 ? returnTypeNode : ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(""))) : - kind === 251 /* FunctionDeclaration */ ? ts.factory.createFunctionDeclaration(/*decorators*/ undefined, options === null || options === void 0 ? void 0 : options.modifiers, /*asteriskToken*/ undefined, (options === null || options === void 0 ? void 0 : options.name) ? ts.cast(options.name, ts.isIdentifier) : ts.factory.createIdentifier(""), typeParameters, parameters, returnTypeNode, /*body*/ undefined) : - kind === 208 /* FunctionExpression */ ? ts.factory.createFunctionExpression(options === null || options === void 0 ? void 0 : options.modifiers, /*asteriskToken*/ undefined, (options === null || options === void 0 ? void 0 : options.name) ? ts.cast(options.name, ts.isIdentifier) : ts.factory.createIdentifier(""), typeParameters, parameters, returnTypeNode, ts.factory.createBlock([])) : - kind === 209 /* ArrowFunction */ ? ts.factory.createArrowFunction(options === null || options === void 0 ? void 0 : options.modifiers, typeParameters, parameters, returnTypeNode, /*equalsGreaterThanToken*/ undefined, ts.factory.createBlock([])) : + kind === 175 /* ConstructorType */ ? ts.factory.createConstructorTypeNode(modifiers, typeParameters, parameters, returnTypeNode !== null && returnTypeNode !== void 0 ? returnTypeNode : ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(""))) : + kind === 251 /* FunctionDeclaration */ ? ts.factory.createFunctionDeclaration(/*decorators*/ undefined, modifiers, /*asteriskToken*/ undefined, (options === null || options === void 0 ? void 0 : options.name) ? ts.cast(options.name, ts.isIdentifier) : ts.factory.createIdentifier(""), typeParameters, parameters, returnTypeNode, /*body*/ undefined) : + kind === 208 /* FunctionExpression */ ? ts.factory.createFunctionExpression(modifiers, /*asteriskToken*/ undefined, (options === null || options === void 0 ? void 0 : options.name) ? ts.cast(options.name, ts.isIdentifier) : ts.factory.createIdentifier(""), typeParameters, parameters, returnTypeNode, ts.factory.createBlock([])) : + kind === 209 /* ArrowFunction */ ? ts.factory.createArrowFunction(modifiers, typeParameters, parameters, returnTypeNode, /*equalsGreaterThanToken*/ undefined, ts.factory.createBlock([])) : ts.Debug.assertNever(kind); if (typeArguments) { node.typeArguments = ts.factory.createNodeArray(typeArguments); @@ -48350,7 +48853,7 @@ var ts; // specifier preference var moduleResolverHost = context.tracker.moduleResolverHost; var specifierCompilerOptions = isBundle_1 ? __assign(__assign({}, compilerOptions), { baseUrl: moduleResolverHost.getCommonSourceDirectory() }) : compilerOptions; - specifier = ts.first(ts.moduleSpecifiers.getModuleSpecifiers(symbol, specifierCompilerOptions, contextFile, moduleResolverHost, { importModuleSpecifierPreference: isBundle_1 ? "non-relative" : "relative", importModuleSpecifierEnding: isBundle_1 ? "minimal" : undefined })); + specifier = ts.first(ts.moduleSpecifiers.getModuleSpecifiers(symbol, checker, specifierCompilerOptions, contextFile, moduleResolverHost, { importModuleSpecifierPreference: isBundle_1 ? "non-relative" : "relative", importModuleSpecifierEnding: isBundle_1 ? "minimal" : undefined })); (_a = links.specifierCache) !== null && _a !== void 0 ? _a : (links.specifierCache = new ts.Map()); links.specifierCache.set(contextFile.path, specifier); } @@ -48675,6 +49178,31 @@ var ts; } return typeToTypeNodeHelper(type, context); } + function trackExistingEntityName(node, context, includePrivateSymbol) { + var _a, _b; + var introducesError = false; + var leftmost = ts.getFirstIdentifier(node); + if (ts.isInJSFile(node) && (ts.isExportsIdentifier(leftmost) || ts.isModuleExportsAccessExpression(leftmost.parent) || (ts.isQualifiedName(leftmost.parent) && ts.isModuleIdentifier(leftmost.parent.left) && ts.isExportsIdentifier(leftmost.parent.right)))) { + introducesError = true; + return { introducesError: introducesError, node: node }; + } + var sym = resolveEntityName(leftmost, 67108863 /* All */, /*ignoreErrors*/ true, /*dontResolveALias*/ true); + if (sym) { + if (isSymbolAccessible(sym, context.enclosingDeclaration, 67108863 /* All */, /*shouldComputeAliasesToMakeVisible*/ false).accessibility !== 0 /* Accessible */) { + introducesError = true; + } + else { + (_b = (_a = context.tracker) === null || _a === void 0 ? void 0 : _a.trackSymbol) === null || _b === void 0 ? void 0 : _b.call(_a, sym, context.enclosingDeclaration, 67108863 /* All */); + includePrivateSymbol === null || includePrivateSymbol === void 0 ? void 0 : includePrivateSymbol(sym); + } + if (ts.isIdentifier(node)) { + var name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(getDeclaredTypeOfSymbol(sym), context) : ts.factory.cloneNode(node); + name.symbol = sym; // for quickinfo, which uses identifier symbol information + return { introducesError: introducesError, node: ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */) }; + } + } + return { introducesError: introducesError, node: node }; + } function serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled) { if (cancellationToken && cancellationToken.throwIfCancellationRequested) { cancellationToken.throwIfCancellationRequested(); @@ -48687,7 +49215,6 @@ var ts; } return transformed === existing ? ts.setTextRange(ts.factory.cloneNode(existing), existing) : transformed; function visitExistingNodeTreeSymbols(node) { - var _a, _b; // We don't _actually_ support jsdoc namepath types, emit `any` instead if (ts.isJSDocAllType(node) || node.kind === 310 /* JSDocNamepathType */) { return ts.factory.createKeywordTypeNode(128 /* AnyKeyword */); @@ -48713,7 +49240,7 @@ var ts; var typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode(node), name.escapedText); var overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode(t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : undefined; return ts.factory.createPropertySignature( - /*modifiers*/ undefined, name, t.typeExpression && ts.isJSDocOptionalType(t.typeExpression.type) ? ts.factory.createToken(57 /* QuestionToken */) : undefined, overrideTypeNode || (t.typeExpression && ts.visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols)) || ts.factory.createKeywordTypeNode(128 /* AnyKeyword */)); + /*modifiers*/ undefined, name, t.isBracketed || t.typeExpression && ts.isJSDocOptionalType(t.typeExpression.type) ? ts.factory.createToken(57 /* QuestionToken */) : undefined, overrideTypeNode || (t.typeExpression && ts.visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols)) || ts.factory.createKeywordTypeNode(128 /* AnyKeyword */)); })); } if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.escapedText === "") { @@ -48731,7 +49258,7 @@ var ts; if (ts.isJSDocFunctionType(node)) { if (ts.isJSDocConstructSignature(node)) { var newTypeNode_1; - return ts.factory.createConstructorTypeNode(ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.mapDefined(node.parameters, function (p, i) { return p.name && ts.isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode_1 = p.type, undefined) : ts.factory.createParameterDeclaration( + return ts.factory.createConstructorTypeNode(node.modifiers, ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.mapDefined(node.parameters, function (p, i) { return p.name && ts.isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode_1 = p.type, undefined) : ts.factory.createParameterDeclaration( /*decorators*/ undefined, /*modifiers*/ undefined, getEffectiveDotDotDotForParameter(p), getNameForJSDocFunctionParameter(p, i), p.questionToken, ts.visitNode(p.type, visitExistingNodeTreeSymbols), /*initializer*/ undefined); }), ts.visitNode(newTypeNode_1 || node.type, visitExistingNodeTreeSymbols) || ts.factory.createKeywordTypeNode(128 /* AnyKeyword */)); @@ -48747,28 +49274,23 @@ var ts; return ts.setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node); } if (ts.isLiteralImportTypeNode(node)) { + var nodeSymbol = getNodeLinks(node).resolvedSymbol; + if (ts.isInJSDoc(node) && + nodeSymbol && + ( + // The import type resolved using jsdoc fallback logic + (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */)) || + // The import type had type arguments autofilled by js fallback logic + !(ts.length(node.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))))) { + return ts.setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node); + } return ts.factory.updateImportTypeNode(node, ts.factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier(node, node.argument.literal)), node.qualifier, ts.visitNodes(node.typeArguments, visitExistingNodeTreeSymbols, ts.isTypeNode), node.isTypeOf); } if (ts.isEntityName(node) || ts.isEntityNameExpression(node)) { - var leftmost = ts.getFirstIdentifier(node); - if (ts.isInJSFile(node) && (ts.isExportsIdentifier(leftmost) || ts.isModuleExportsAccessExpression(leftmost.parent) || (ts.isQualifiedName(leftmost.parent) && ts.isModuleIdentifier(leftmost.parent.left) && ts.isExportsIdentifier(leftmost.parent.right)))) { - hadError = true; - return node; - } - var sym = resolveEntityName(leftmost, 67108863 /* All */, /*ignoreErrors*/ true, /*dontResolveALias*/ true); - if (sym) { - if (isSymbolAccessible(sym, context.enclosingDeclaration, 67108863 /* All */, /*shouldComputeAliasesToMakeVisible*/ false).accessibility !== 0 /* Accessible */) { - hadError = true; - } - else { - (_b = (_a = context.tracker) === null || _a === void 0 ? void 0 : _a.trackSymbol) === null || _b === void 0 ? void 0 : _b.call(_a, sym, context.enclosingDeclaration, 67108863 /* All */); - includePrivateSymbol === null || includePrivateSymbol === void 0 ? void 0 : includePrivateSymbol(sym); - } - if (ts.isIdentifier(node)) { - var name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(getDeclaredTypeOfSymbol(sym), context) : ts.factory.cloneNode(node); - name.symbol = sym; // for quickinfo, which uses identifier symbol information - return ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */); - } + var _a = trackExistingEntityName(node, context, includePrivateSymbol), introducesError = _a.introducesError, result = _a.node; + hadError = hadError || introducesError; + if (result !== node) { + return result; } } if (file && ts.isTupleTypeNode(node) && (ts.getLineAndCharacterOfPosition(file, node.pos).line === ts.getLineAndCharacterOfPosition(file, node.end).line)) { @@ -48826,7 +49348,7 @@ var ts; var deferredPrivatesStack = []; var oldcontext = context; context = __assign(__assign({}, oldcontext), { usedSymbolNames: new ts.Set(oldcontext.usedSymbolNames), remappedSymbolNames: new ts.Map(), tracker: __assign(__assign({}, oldcontext.tracker), { trackSymbol: function (sym, decl, meaning) { - var accessibleResult = isSymbolAccessible(sym, decl, meaning, /*computeALiases*/ false); + var accessibleResult = isSymbolAccessible(sym, decl, meaning, /*computeAliases*/ false); if (accessibleResult.accessibility === 0 /* Accessible */) { // Lookup the root symbol of the chain of refs we'll use to access it and serialize it var chain = lookupSymbolChainWorker(sym, context, meaning); @@ -48873,12 +49395,12 @@ var ts; var name_2 = ns.name; var body = ns.body; if (ts.length(excessExports)) { - ns = ts.factory.updateModuleDeclaration(ns, ns.decorators, ns.modifiers, ns.name, body = ts.factory.updateModuleBlock(body, ts.factory.createNodeArray(__spreadArrays(ns.body.statements, [ts.factory.createExportDeclaration( + ns = ts.factory.updateModuleDeclaration(ns, ns.decorators, ns.modifiers, ns.name, body = ts.factory.updateModuleBlock(body, ts.factory.createNodeArray(__spreadArray(__spreadArray([], ns.body.statements), [ts.factory.createExportDeclaration( /*decorators*/ undefined, /*modifiers*/ undefined, /*isTypeOnly*/ false, ts.factory.createNamedExports(ts.map(ts.flatMap(excessExports, function (e) { return getNamesOfDeclaration(e); }), function (id) { return ts.factory.createExportSpecifier(/*alias*/ undefined, id); })), /*moduleSpecifier*/ undefined)])))); - statements = __spreadArrays(statements.slice(0, nsIndex), [ns], statements.slice(nsIndex + 1)); + statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, nsIndex)), [ns]), statements.slice(nsIndex + 1)); } // Pass 1: Flatten `export namespace _exports {} export = _exports;` so long as the `export=` only points at a single namespace declaration if (!ts.find(statements, function (s) { return s !== ns && ts.nodeHasName(s, name_2); })) { @@ -48889,7 +49411,7 @@ var ts; ts.forEach(body.statements, function (s) { addResult(s, mixinExportFlag_1 ? 1 /* Export */ : 0 /* None */); // Recalculates the ambient (and export, if applicable from above) flag }); - statements = __spreadArrays(ts.filter(statements, function (s) { return s !== ns && s !== exportAssignment; }), results); + statements = __spreadArray(__spreadArray([], ts.filter(statements, function (s) { return s !== ns && s !== exportAssignment; })), results); } } return statements; @@ -48899,7 +49421,7 @@ var ts; var exports = ts.filter(statements, function (d) { return ts.isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause && ts.isNamedExports(d.exportClause); }); if (ts.length(exports) > 1) { var nonExports = ts.filter(statements, function (d) { return !ts.isExportDeclaration(d) || !!d.moduleSpecifier || !d.exportClause; }); - statements = __spreadArrays(nonExports, [ts.factory.createExportDeclaration( + statements = __spreadArray(__spreadArray([], nonExports), [ts.factory.createExportDeclaration( /*decorators*/ undefined, /*modifiers*/ undefined, /*isTypeOnly*/ false, ts.factory.createNamedExports(ts.flatMap(exports, function (e) { return ts.cast(e.exportClause, ts.isNamedExports).elements; })), @@ -48913,7 +49435,7 @@ var ts; var _loop_9 = function (group_1) { if (group_1.length > 1) { // remove group members from statements and then merge group members and add back to statements - statements = __spreadArrays(ts.filter(statements, function (s) { return group_1.indexOf(s) === -1; }), [ + statements = __spreadArray(__spreadArray([], ts.filter(statements, function (s) { return group_1.indexOf(s) === -1; })), [ ts.factory.createExportDeclaration( /*decorators*/ undefined, /*modifiers*/ undefined, @@ -49214,15 +49736,16 @@ var ts; function addResult(node, additionalModifierFlags) { if (ts.canHaveModifiers(node)) { var newModifierFlags = 0 /* None */; + var enclosingDeclaration_1 = context.enclosingDeclaration && + (ts.isJSDocTypeAlias(context.enclosingDeclaration) ? ts.getSourceFileOfNode(context.enclosingDeclaration) : context.enclosingDeclaration); if (additionalModifierFlags & 1 /* Export */ && - context.enclosingDeclaration && - (isExportingScope(context.enclosingDeclaration) || ts.isModuleDeclaration(context.enclosingDeclaration)) && + enclosingDeclaration_1 && (isExportingScope(enclosingDeclaration_1) || ts.isModuleDeclaration(enclosingDeclaration_1)) && canHaveExportModifier(node)) { // Classes, namespaces, variables, functions, interfaces, and types should all be `export`ed in a module context if not private newModifierFlags |= 1 /* Export */; } if (addingDeclare && !(newModifierFlags & 1 /* Export */) && - (!context.enclosingDeclaration || !(context.enclosingDeclaration.flags & 8388608 /* Ambient */)) && + (!enclosingDeclaration_1 || !(enclosingDeclaration_1.flags & 8388608 /* Ambient */)) && (ts.isEnumDeclaration(node) || ts.isVariableStatement(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isModuleDeclaration(node))) { // Classes, namespaces, variables, enums, and functions all need `declare` modifiers to be valid in a declaration file top-level scope newModifierFlags |= 2 /* Ambient */; @@ -49244,8 +49767,15 @@ var ts; var commentText = jsdocAliasDecl ? jsdocAliasDecl.comment || jsdocAliasDecl.parent.comment : undefined; var oldFlags = context.flags; context.flags |= 8388608 /* InTypeAlias */; - addResult(ts.setSyntheticLeadingComments(ts.factory.createTypeAliasDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, getInternalSymbolName(symbol, symbolName), typeParamDecls, typeToTypeNodeHelper(aliasType, context)), !commentText ? [] : [{ kind: 3 /* MultiLineCommentTrivia */, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]), modifierFlags); + var oldEnclosingDecl = context.enclosingDeclaration; + context.enclosingDeclaration = jsdocAliasDecl; + var typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression + && ts.isJSDocTypeExpression(jsdocAliasDecl.typeExpression) + && serializeExistingTypeNode(context, jsdocAliasDecl.typeExpression.type, includePrivateSymbol, bundled) + || typeToTypeNodeHelper(aliasType, context); + addResult(ts.setSyntheticLeadingComments(ts.factory.createTypeAliasDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, getInternalSymbolName(symbol, symbolName), typeParamDecls, typeNode), !commentText ? [] : [{ kind: 3 /* MultiLineCommentTrivia */, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]), modifierFlags); context.flags = oldFlags; + context.enclosingDeclaration = oldEnclosingDecl; } function serializeInterface(symbol, symbolName, modifierFlags) { var interfaceType = getDeclaredTypeOfClassOrInterface(symbol); @@ -49260,7 +49790,7 @@ var ts; var heritageClauses = !ts.length(baseTypes) ? undefined : [ts.factory.createHeritageClause(93 /* ExtendsKeyword */, ts.mapDefined(baseTypes, function (b) { return trySerializeAsTypeReference(b, 111551 /* Value */); }))]; addResult(ts.factory.createInterfaceDeclaration( /*decorators*/ undefined, - /*modifiers*/ undefined, getInternalSymbolName(symbol, symbolName), typeParamDecls, heritageClauses, __spreadArrays(indexSignatures, constructSignatures, callSignatures, members)), modifierFlags); + /*modifiers*/ undefined, getInternalSymbolName(symbol, symbolName), typeParamDecls, heritageClauses, __spreadArray(__spreadArray(__spreadArray(__spreadArray([], indexSignatures), constructSignatures), callSignatures), members)), modifierFlags); } function getNamespaceMembersForSerialization(symbol) { return !symbol.exports ? [] : ts.filter(ts.arrayFrom(symbol.exports.values()), isNamespaceMember); @@ -49389,19 +49919,54 @@ var ts; return !!(p.flags & (788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */)) || !(p.flags & 4194304 /* Prototype */ || p.escapedName === "prototype" || p.valueDeclaration && ts.getEffectiveModifierFlags(p.valueDeclaration) & 32 /* Static */ && ts.isClassLike(p.valueDeclaration.parent)); } + function sanitizeJSDocImplements(clauses) { + var result = ts.mapDefined(clauses, function (e) { + var _a; + var oldEnclosing = context.enclosingDeclaration; + context.enclosingDeclaration = e; + var expr = e.expression; + if (ts.isEntityNameExpression(expr)) { + if (ts.isIdentifier(expr) && ts.idText(expr) === "") { + return cleanup(/*result*/ undefined); // Empty heritage clause, should be an error, but prefer emitting no heritage clauses to reemitting the empty one + } + var introducesError = void 0; + (_a = trackExistingEntityName(expr, context, includePrivateSymbol), introducesError = _a.introducesError, expr = _a.node); + if (introducesError) { + return cleanup(/*result*/ undefined); + } + } + return cleanup(ts.factory.createExpressionWithTypeArguments(expr, ts.map(e.typeArguments, function (a) { + return serializeExistingTypeNode(context, a, includePrivateSymbol, bundled) + || typeToTypeNodeHelper(getTypeFromTypeNode(a), context); + }))); + function cleanup(result) { + context.enclosingDeclaration = oldEnclosing; + return result; + } + }); + if (result.length === clauses.length) { + return result; + } + return undefined; + } function serializeAsClass(symbol, localName, modifierFlags) { var _a; + var originalDecl = ts.find(symbol.declarations, ts.isClassLike); + var oldEnclosing = context.enclosingDeclaration; + context.enclosingDeclaration = originalDecl || oldEnclosing; var localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); var typeParamDecls = ts.map(localParams, function (p) { return typeParameterToDeclaration(p, context); }); var classType = getDeclaredTypeOfClassOrInterface(symbol); var baseTypes = getBaseTypes(classType); - var implementsExpressions = ts.mapDefined(getImplementsTypes(classType), serializeImplementedType); + var originalImplements = originalDecl && ts.getEffectiveImplementsTypeNodes(originalDecl); + var implementsExpressions = originalImplements && sanitizeJSDocImplements(originalImplements) + || ts.mapDefined(getImplementsTypes(classType), serializeImplementedType); var staticType = getTypeOfSymbol(symbol); var isClass = !!((_a = staticType.symbol) === null || _a === void 0 ? void 0 : _a.valueDeclaration) && ts.isClassLike(staticType.symbol.valueDeclaration); var staticBaseType = isClass ? getBaseConstructorTypeOfClass(staticType) : anyType; - var heritageClauses = __spreadArrays(!ts.length(baseTypes) ? [] : [ts.factory.createHeritageClause(93 /* ExtendsKeyword */, ts.map(baseTypes, function (b) { return serializeBaseType(b, staticBaseType, localName); }))], !ts.length(implementsExpressions) ? [] : [ts.factory.createHeritageClause(116 /* ImplementsKeyword */, implementsExpressions)]); + var heritageClauses = __spreadArray(__spreadArray([], !ts.length(baseTypes) ? [] : [ts.factory.createHeritageClause(93 /* ExtendsKeyword */, ts.map(baseTypes, function (b) { return serializeBaseType(b, staticBaseType, localName); }))]), !ts.length(implementsExpressions) ? [] : [ts.factory.createHeritageClause(116 /* ImplementsKeyword */, implementsExpressions)]); var symbolProps = getNonInterhitedProperties(classType, baseTypes, getPropertiesOfType(classType)); var publicSymbolProps = ts.filter(symbolProps, function (s) { // `valueDeclaration` could be undefined if inherited from @@ -49438,11 +50003,12 @@ var ts; !ts.some(getSignaturesOfType(staticType, 1 /* Construct */)); var constructors = isNonConstructableClassLikeInJsFile ? [ts.factory.createConstructorDeclaration(/*decorators*/ undefined, ts.factory.createModifiersFromModifierFlags(8 /* Private */), [], /*body*/ undefined)] : - serializeSignatures(1 /* Construct */, staticType, baseTypes[0], 166 /* Constructor */); + serializeSignatures(1 /* Construct */, staticType, staticBaseType, 166 /* Constructor */); var indexSignatures = serializeIndexSignatures(classType, baseTypes[0]); + context.enclosingDeclaration = oldEnclosing; addResult(ts.setTextRange(ts.factory.createClassDeclaration( /*decorators*/ undefined, - /*modifiers*/ undefined, localName, typeParamDecls, heritageClauses, __spreadArrays(indexSignatures, staticMembers, constructors, publicProperties, privateProperties)), symbol.declarations && ts.filter(symbol.declarations, function (d) { return ts.isClassDeclaration(d) || ts.isClassExpression(d); })[0]), modifierFlags); + /*modifiers*/ undefined, localName, typeParamDecls, heritageClauses, __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], indexSignatures), staticMembers), constructors), publicProperties), privateProperties)), symbol.declarations && ts.filter(symbol.declarations, function (d) { return ts.isClassDeclaration(d) || ts.isClassExpression(d); })[0]), modifierFlags); } function serializeAsAlias(symbol, localName, modifierFlags) { var _a, _b, _c, _d, _e; @@ -49493,11 +50059,13 @@ var ts; // import _x = require('y'); addResult(ts.factory.createImportEqualsDeclaration( /*decorators*/ undefined, - /*modifiers*/ undefined, uniqueName, ts.factory.createExternalModuleReference(ts.factory.createStringLiteral(specifier_2))), 0 /* None */); + /*modifiers*/ undefined, + /*isTypeOnly*/ false, uniqueName, ts.factory.createExternalModuleReference(ts.factory.createStringLiteral(specifier_2))), 0 /* None */); // import x = _x.z addResult(ts.factory.createImportEqualsDeclaration( /*decorators*/ undefined, - /*modifiers*/ undefined, ts.factory.createIdentifier(localName), ts.factory.createQualifiedName(uniqueName, initializer.name)), modifierFlags); + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createIdentifier(localName), ts.factory.createQualifiedName(uniqueName, initializer.name)), modifierFlags); break; } // else fall through and treat commonjs require just like import= @@ -49513,7 +50081,8 @@ var ts; var isLocalImport = !(target.flags & 512 /* ValueModule */) && !ts.isVariableDeclaration(node); addResult(ts.factory.createImportEqualsDeclaration( /*decorators*/ undefined, - /*modifiers*/ undefined, ts.factory.createIdentifier(localName), isLocalImport + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createIdentifier(localName), isLocalImport ? symbolToName(target, context, 67108863 /* All */, /*expectsIdentifier*/ false) : ts.factory.createExternalModuleReference(ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target, context)))), isLocalImport ? modifierFlags : 0 /* None */); break; @@ -49639,7 +50208,8 @@ var ts; var varName = getUnusedName(name, symbol); addResult(ts.factory.createImportEqualsDeclaration( /*decorators*/ undefined, - /*modifiers*/ undefined, ts.factory.createIdentifier(varName), symbolToName(target, context, 67108863 /* All */, /*expectsIdentifier*/ false)), 0 /* None */); + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createIdentifier(varName), symbolToName(target, context, 67108863 /* All */, /*expectsIdentifier*/ false)), 0 /* None */); serializeExportSpecifier(name, varName); } } @@ -50542,7 +51112,7 @@ var ts; if (ts.isParameter(declaration)) { var func = declaration.parent; // For a parameter of a set accessor, use the type of the get accessor if one is present - if (func.kind === 168 /* SetAccessor */ && !hasNonBindableDynamicName(func)) { + if (func.kind === 168 /* SetAccessor */ && hasBindableName(func)) { var getter = ts.getDeclarationOfKind(getSymbolOfNode(declaration.parent), 167 /* GetAccessor */); if (getter) { var getterSignature = getSignatureFromDeclaration(getter); @@ -51038,8 +51608,18 @@ var ts; } if (symbol.flags & 134217728 /* ModuleExports */) { var fileSymbol = getSymbolOfNode(ts.getSourceFileOfNode(symbol.valueDeclaration)); + var result = createSymbol(fileSymbol.flags, "exports"); + result.declarations = fileSymbol.declarations ? fileSymbol.declarations.slice() : []; + result.parent = symbol; + result.target = fileSymbol; + if (fileSymbol.valueDeclaration) + result.valueDeclaration = fileSymbol.valueDeclaration; + if (fileSymbol.members) + result.members = new ts.Map(fileSymbol.members); + if (fileSymbol.exports) + result.exports = new ts.Map(fileSymbol.exports); var members = ts.createSymbolTable(); - members.set("exports", fileSymbol); + members.set("exports", result); return createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, undefined, undefined); } // Handle catch clause variables @@ -51496,7 +52076,10 @@ var ts; var signatures = getSignaturesOfType(type, 1 /* Construct */); if (signatures.length === 1) { var s = signatures[0]; - return !s.typeParameters && s.parameters.length === 1 && signatureHasRestParameter(s) && getElementTypeOfArrayType(getTypeOfParameter(s.parameters[0])) === anyType; + if (!s.typeParameters && s.parameters.length === 1 && signatureHasRestParameter(s)) { + var paramType = getTypeOfParameter(s.parameters[0]); + return isTypeAny(paramType) || getElementTypeOfArrayType(paramType) === anyType; + } } return false; } @@ -52114,10 +52697,10 @@ var ts; return !!name && isLateBindableName(name); } /** - * Indicates whether a declaration has a dynamic name that cannot be late-bound. + * Indicates whether a declaration has an early-bound name or a dynamic name that can be late-bound. */ - function hasNonBindableDynamicName(node) { - return ts.hasDynamicName(node) && !hasLateBindableName(node); + function hasBindableName(node) { + return !ts.hasDynamicName(node) || hasLateBindableName(node); } /** * Indicates whether a declaration name is a dynamic name that cannot be late-bound. @@ -52315,7 +52898,8 @@ var ts; } } else if (type.flags & 2097152 /* Intersection */) { - return getIntersectionType(ts.map(type.types, function (t) { return getTypeWithThisArgument(t, thisArgument, needApparentType); })); + var types = ts.sameMap(type.types, function (t) { return getTypeWithThisArgument(t, thisArgument, needApparentType); }); + return types !== type.types ? getIntersectionType(types) : type; } return needApparentType ? getApparentType(type) : type; } @@ -52391,7 +52975,7 @@ var ts; } function cloneSignature(sig) { var result = createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, /*resolvedReturnType*/ undefined, - /*resolvedTypePredicate*/ undefined, sig.minArgumentCount, sig.flags & 19 /* PropagatingFlags */); + /*resolvedTypePredicate*/ undefined, sig.minArgumentCount, sig.flags & 39 /* PropagatingFlags */); result.target = sig.target; result.mapper = sig.mapper; result.unionSignatures = sig.unionSignatures; @@ -52405,18 +52989,18 @@ var ts; return result; } function getOptionalCallSignature(signature, callChainFlags) { - if ((signature.flags & 12 /* CallChainFlags */) === callChainFlags) { + if ((signature.flags & 24 /* CallChainFlags */) === callChainFlags) { return signature; } if (!signature.optionalCallSignatureCache) { signature.optionalCallSignatureCache = {}; } - var key = callChainFlags === 4 /* IsInnerCallChain */ ? "inner" : "outer"; + var key = callChainFlags === 8 /* IsInnerCallChain */ ? "inner" : "outer"; return signature.optionalCallSignatureCache[key] || (signature.optionalCallSignatureCache[key] = createOptionalCallSignature(signature, callChainFlags)); } function createOptionalCallSignature(signature, callChainFlags) { - ts.Debug.assert(callChainFlags === 4 /* IsInnerCallChain */ || callChainFlags === 8 /* IsOuterCallChain */, "An optional call signature can either be for an inner call chain or an outer call chain, but not both."); + ts.Debug.assert(callChainFlags === 8 /* IsInnerCallChain */ || callChainFlags === 16 /* IsOuterCallChain */, "An optional call signature can either be for an inner call chain or an outer call chain, but not both."); var result = cloneSignature(signature); result.flags |= callChainFlags; return result; @@ -52453,8 +53037,10 @@ var ts; function getDefaultConstructSignatures(classType) { var baseConstructorType = getBaseConstructorTypeOfClass(classType); var baseSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */); + var declaration = ts.getClassLikeDeclarationOfSymbol(classType.symbol); + var isAbstract = !!declaration && ts.hasSyntacticModifier(declaration, 128 /* Abstract */); if (baseSignatures.length === 0) { - return [createSignature(undefined, classType.localTypeParameters, undefined, ts.emptyArray, classType, /*resolvedTypePredicate*/ undefined, 0, 0 /* None */)]; + return [createSignature(undefined, classType.localTypeParameters, undefined, ts.emptyArray, classType, /*resolvedTypePredicate*/ undefined, 0, isAbstract ? 4 /* Abstract */ : 0 /* None */)]; } var baseTypeNode = getBaseTypeNodeOfClass(classType); var isJavaScript = ts.isInJSFile(baseTypeNode); @@ -52469,6 +53055,7 @@ var ts; var sig = typeParamCount ? createSignatureInstantiation(baseSig, fillMissingTypeArguments(typeArguments, baseSig.typeParameters, minTypeArgumentCount, isJavaScript)) : cloneSignature(baseSig); sig.typeParameters = classType.localTypeParameters; sig.resolvedReturnType = classType; + sig.flags = isAbstract ? sig.flags | 4 /* Abstract */ : sig.flags & ~4 /* Abstract */; result.push(sig); } } @@ -52555,7 +53142,7 @@ var ts; if (signatures !== masterList) { var signature_1 = signatures[0]; ts.Debug.assert(!!signature_1, "getUnionSignatures bails early on empty signature lists and should not have empty lists on second pass"); - results = signature_1.typeParameters && ts.some(results, function (s) { return !!s.typeParameters; }) ? undefined : ts.map(results, function (sig) { return combineSignaturesOfUnionMembers(sig, signature_1); }); + results = signature_1.typeParameters && ts.some(results, function (s) { return !!s.typeParameters && !compareTypeParametersIdentical(signature_1.typeParameters, s.typeParameters); }) ? undefined : ts.map(results, function (sig) { return combineSignaturesOfUnionMembers(sig, signature_1); }); if (!results) { return "break"; } @@ -52571,17 +53158,37 @@ var ts; } return result || ts.emptyArray; } - function combineUnionThisParam(left, right) { + function compareTypeParametersIdentical(sourceParams, targetParams) { + if (sourceParams.length !== targetParams.length) { + return false; + } + var mapper = createTypeMapper(targetParams, sourceParams); + for (var i = 0; i < sourceParams.length; i++) { + var source = sourceParams[i]; + var target = targetParams[i]; + if (source === target) + continue; + // We instantiate the target type parameter constraints into the source types so we can recognize `` as the same as `` + if (!isTypeIdenticalTo(getConstraintFromTypeParameter(source) || unknownType, instantiateType(getConstraintFromTypeParameter(target) || unknownType, mapper))) + return false; + // We don't compare defaults - we just use the type parameter defaults from the first signature that seems to match. + // It might make sense to combine these defaults in the future, but doing so intelligently requires knowing + // if the parameter is used covariantly or contravariantly (so we intersect if it's used like a parameter or union if used like a return type) + // and, since it's just an inference _default_, just picking one arbitrarily works OK. + } + return true; + } + function combineUnionThisParam(left, right, mapper) { if (!left || !right) { return left || right; } // A signature `this` type might be a read or a write position... It's very possible that it should be invariant // and we should refuse to merge signatures if there are `this` types and they do not match. However, so as to be // permissive when calling, for now, we'll intersect the `this` types just like we do for param types in union signatures. - var thisType = getIntersectionType([getTypeOfSymbol(left), getTypeOfSymbol(right)]); + var thisType = getIntersectionType([getTypeOfSymbol(left), instantiateType(getTypeOfSymbol(right), mapper)]); return createSymbolWithType(left, thisType); } - function combineUnionParameters(left, right) { + function combineUnionParameters(left, right, mapper) { var leftCount = getParameterCount(left); var rightCount = getParameterCount(right); var longest = leftCount >= rightCount ? left : right; @@ -52592,7 +53199,13 @@ var ts; var params = new Array(longestCount + (needsExtraRestElement ? 1 : 0)); for (var i = 0; i < longestCount; i++) { var longestParamType = tryGetTypeAtPosition(longest, i); + if (longest === right) { + longestParamType = instantiateType(longestParamType, mapper); + } var shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType; + if (shorter === right) { + shorterParamType = instantiateType(shorterParamType, mapper); + } var unionParamType = getIntersectionType([longestParamType, shorterParamType]); var isRestParam = eitherHasEffectiveRest && !needsExtraRestElement && i === (longestCount - 1); var isOptional = i >= getMinArgumentCount(longest) && i >= getMinArgumentCount(shorter); @@ -52609,19 +53222,31 @@ var ts; if (needsExtraRestElement) { var restParamSymbol = createSymbol(1 /* FunctionScopedVariable */, "args"); restParamSymbol.type = createArrayType(getTypeAtPosition(shorter, longestCount)); + if (shorter === right) { + restParamSymbol.type = instantiateType(restParamSymbol.type, mapper); + } params[longestCount] = restParamSymbol; } return params; } function combineSignaturesOfUnionMembers(left, right) { + var typeParams = left.typeParameters || right.typeParameters; + var paramMapper; + if (left.typeParameters && right.typeParameters) { + paramMapper = createTypeMapper(right.typeParameters, left.typeParameters); + // We just use the type parameter defaults from the first signature + } var declaration = left.declaration; - var params = combineUnionParameters(left, right); - var thisParam = combineUnionThisParam(left.thisParameter, right.thisParameter); + var params = combineUnionParameters(left, right, paramMapper); + var thisParam = combineUnionThisParam(left.thisParameter, right.thisParameter, paramMapper); var minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount); - var result = createSignature(declaration, left.typeParameters || right.typeParameters, thisParam, params, + var result = createSignature(declaration, typeParams, thisParam, params, /*resolvedReturnType*/ undefined, - /*resolvedTypePredicate*/ undefined, minArgCount, (left.flags | right.flags) & 19 /* PropagatingFlags */); + /*resolvedTypePredicate*/ undefined, minArgCount, (left.flags | right.flags) & 39 /* PropagatingFlags */); result.unionSignatures = ts.concatenate(left.unionSignatures || [left], [right]); + if (paramMapper) { + result.mapper = left.mapper && left.unionSignatures ? combineTypeMappers(left.mapper, paramMapper) : paramMapper; + } return result; } function getUnionIndexInfo(types, kind) { @@ -52793,7 +53418,7 @@ var ts; var constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor" /* Constructor */)) : ts.emptyArray; if (symbol.flags & 16 /* Function */) { constructSignatures = ts.addRange(constructSignatures.slice(), ts.mapDefined(type.callSignatures, function (sig) { return isJSConstructor(sig.declaration) ? - createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType_1, /*resolvedTypePredicate*/ undefined, sig.minArgumentCount, sig.flags & 19 /* PropagatingFlags */) : + createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType_1, /*resolvedTypePredicate*/ undefined, sig.minArgumentCount, sig.flags & 39 /* PropagatingFlags */) : undefined; })); } if (!constructSignatures.length) { @@ -52842,13 +53467,16 @@ var ts; return type; } if (type.flags & 1048576 /* Union */) { - return getUnionType(ts.sameMap(type.types, getLowerBoundOfKeyType)); + return mapType(type, getLowerBoundOfKeyType); } if (type.flags & 2097152 /* Intersection */) { return getIntersectionType(ts.sameMap(type.types, getLowerBoundOfKeyType)); } return type; } + function getIsLateCheckFlag(s) { + return ts.getCheckFlags(s) & 4096 /* Late */; + } /** Resolve the members of a mapped type { [P in K]: T } */ function resolveMappedTypeMembers(type) { var members = ts.createSymbolTable(); @@ -52906,7 +53534,8 @@ var ts; var isReadonly = !!(templateModifiers & 1 /* IncludeReadonly */ || !(templateModifiers & 2 /* ExcludeReadonly */) && modifiersProp && isReadonlySymbol(modifiersProp)); var stripOptional = strictNullChecks && !isOptional && modifiersProp && modifiersProp.flags & 16777216 /* Optional */; - var prop = createSymbol(4 /* Property */ | (isOptional ? 16777216 /* Optional */ : 0), propName, 262144 /* Mapped */ | (isReadonly ? 8 /* Readonly */ : 0) | (stripOptional ? 524288 /* StripOptional */ : 0)); + var lateFlag = modifiersProp ? getIsLateCheckFlag(modifiersProp) : 0; + var prop = createSymbol(4 /* Property */ | (isOptional ? 16777216 /* Optional */ : 0), propName, lateFlag | 262144 /* Mapped */ | (isReadonly ? 8 /* Readonly */ : 0) | (stripOptional ? 524288 /* StripOptional */ : 0)); prop.mappedType = type; prop.nameType = propNameType; prop.keyType = keyType; @@ -53263,7 +53892,6 @@ var ts; if (type.resolvedBaseConstraint) { return type.resolvedBaseConstraint; } - var nonTerminating = false; var stack = []; return type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), type); function getImmediateBaseConstraint(t) { @@ -53271,22 +53899,16 @@ var ts; if (!pushTypeResolution(t, 4 /* ImmediateBaseConstraint */)) { return circularConstraintType; } - if (constraintDepth >= 50) { - // We have reached 50 recursive invocations of getImmediateBaseConstraint and there is a - // very high likelihood we're dealing with an infinite generic type that perpetually generates - // new type identities as we descend into it. We stop the recursion here and mark this type - // and the outer types as having circular constraints. - ts.tracing.instant("check" /* Check */, "getImmediateBaseConstraint_DepthLimit", { typeId: t.id, originalTypeId: type.id, depth: constraintDepth }); - error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite); - nonTerminating = true; - return t.immediateBaseConstraint = noConstraintType; - } var result = void 0; - if (!isDeeplyNestedType(t, stack, stack.length)) { + // We always explore at least 10 levels of nested constraints. Thereafter, we continue to explore + // up to 50 levels of nested constraints provided there are no "deeply nested" types on the stack + // (i.e. no types for which five instantiations have been recorded on the stack). If we reach 50 + // levels of nesting, we are presumably exploring a repeating pattern with a long cycle that hasn't + // yet triggered the deeply nested limiter. We have no test cases that actually get to 50 levels of + // nesting, so it is effectively just a safety stop. + if (stack.length < 10 || stack.length < 50 && !isDeeplyNestedType(t, stack, stack.length)) { stack.push(t); - constraintDepth++; result = computeBaseConstraint(getSimplifiedType(t, /*writing*/ false)); - constraintDepth--; stack.pop(); } if (!popTypeResolution()) { @@ -53301,9 +53923,6 @@ var ts; } result = circularConstraintType; } - if (nonTerminating) { - result = circularConstraintType; - } t.immediateBaseConstraint = result || noConstraintType; } return t.immediateBaseConstraint; @@ -53322,12 +53941,22 @@ var ts; if (t.flags & 3145728 /* UnionOrIntersection */) { var types = t.types; var baseTypes = []; + var different = false; for (var _i = 0, types_8 = types; _i < types_8.length; _i++) { var type_3 = types_8[_i]; var baseType = getBaseConstraint(type_3); if (baseType) { + if (baseType !== type_3) { + different = true; + } baseTypes.push(baseType); } + else { + different = true; + } + } + if (!different) { + return t; } return t.flags & 1048576 /* Union */ && baseTypes.length === types.length ? getUnionType(baseTypes) : t.flags & 2097152 /* Intersection */ && baseTypes.length ? getIntersectionType(baseTypes) : @@ -53353,10 +53982,7 @@ var ts; } if (t.flags & 16777216 /* Conditional */) { var constraint = getConstraintFromConditionalType(t); - constraintDepth++; // Penalize repeating conditional types (this captures the recursion within getConstraintFromConditionalType and carries it forward) - var result = constraint && getBaseConstraint(constraint); - constraintDepth--; - return result; + return constraint && getBaseConstraint(constraint); } if (t.flags & 33554432 /* Substitution */) { return getBaseConstraint(t.substitute); @@ -53449,7 +54075,7 @@ var ts; // that type may need further reduction to remove empty intersections. return getReducedType(getApparentType(getReducedType(type))); } - function createUnionOrIntersectionProperty(containingType, name) { + function createUnionOrIntersectionProperty(containingType, name, skipObjectFunctionPropertyAugment) { var singleProp; var propSet; var indexTypes; @@ -53462,7 +54088,7 @@ var ts; var current = _a[_i]; var type = getApparentType(current); if (!(type === errorType || type.flags & 131072 /* Never */)) { - var prop = getPropertyOfType(type, name); + var prop = getPropertyOfType(type, name, skipObjectFunctionPropertyAugment); var modifiers = prop ? ts.getDeclarationModifierFlagsFromSymbol(prop) : 0; if (prop) { if (isUnion) { @@ -53577,19 +54203,21 @@ var ts; // constituents, in which case the isPartial flag is set when the containing type is union type. We need // these partial properties when identifying discriminant properties, but otherwise they are filtered out // and do not appear to be present in the union type. - function getUnionOrIntersectionProperty(type, name) { - var properties = type.propertyCache || (type.propertyCache = ts.createSymbolTable()); - var property = properties.get(name); + function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) { + var _a, _b; + var property = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) === null || _a === void 0 ? void 0 : _a.get(name)) || + !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) === null || _b === void 0 ? void 0 : _b.get(name) : undefined; if (!property) { - property = createUnionOrIntersectionProperty(type, name); + property = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment); if (property) { + var properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = ts.createSymbolTable()) : type.propertyCache || (type.propertyCache = ts.createSymbolTable()); properties.set(name, property); } } return property; } - function getPropertyOfUnionOrIntersectionType(type, name) { - var property = getUnionOrIntersectionProperty(type, name); + function getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment) { + var property = getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment); // We need to filter out partial properties in union types return property && !(ts.getCheckFlags(property) & 16 /* ReadPartial */) ? property : undefined; } @@ -53658,7 +54286,7 @@ var ts; * @param type a type to look up property from * @param name a name of property to look up in a given type */ - function getPropertyOfType(type, name) { + function getPropertyOfType(type, name, skipObjectFunctionPropertyAugment) { type = getReducedApparentType(type); if (type.flags & 524288 /* Object */) { var resolved = resolveStructuredTypeMembers(type); @@ -53666,6 +54294,8 @@ var ts; if (symbol && symbolIsValue(symbol)) { return symbol; } + if (skipObjectFunctionPropertyAugment) + return undefined; var functionType = resolved === anyFunctionType ? globalFunctionType : resolved.callSignatures.length ? globalCallableFunctionType : resolved.constructSignatures.length ? globalNewableFunctionType : @@ -53679,7 +54309,7 @@ var ts; return getPropertyOfObjectType(globalObjectType, name); } if (type.flags & 3145728 /* UnionOrIntersection */) { - return getPropertyOfUnionOrIntersectionType(type, name); + return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment); } return undefined; } @@ -53858,7 +54488,7 @@ var ts; !ts.hasJSDocParameterTags(declaration) && !ts.getJSDocType(declaration); if (isUntypedSignatureInJSFile) { - flags |= 16 /* IsUntypedSignatureInJSFile */; + flags |= 32 /* IsUntypedSignatureInJSFile */; } // If this is a JSDoc construct signature, then skip the first parameter in the // parameter list. The first parameter represents the return type of the construct @@ -53893,7 +54523,7 @@ var ts; } // If only one accessor includes a this-type annotation, the other behaves as if it had the same type annotation if ((declaration.kind === 167 /* GetAccessor */ || declaration.kind === 168 /* SetAccessor */) && - !hasNonBindableDynamicName(declaration) && + hasBindableName(declaration) && (!hasThisParameter || !thisParameter)) { var otherKind = declaration.kind === 167 /* GetAccessor */ ? 168 /* SetAccessor */ : 167 /* GetAccessor */; var other = ts.getDeclarationOfKind(getSymbolOfNode(declaration), otherKind); @@ -53908,6 +54538,10 @@ var ts; if (ts.hasRestParameter(declaration) || ts.isInJSFile(declaration) && maybeAddJsSyntheticRestParameter(declaration, parameters)) { flags |= 1 /* HasRestParameter */; } + if (ts.isConstructorTypeNode(declaration) && ts.hasSyntacticModifier(declaration, 128 /* Abstract */) || + ts.isConstructorDeclaration(declaration) && ts.hasSyntacticModifier(declaration.parent, 128 /* Abstract */)) { + flags |= 4 /* Abstract */; + } links.resolvedSignature = createSignature(declaration, typeParameters, thisParameter, parameters, /*resolvedReturnType*/ undefined, /*resolvedTypePredicate*/ undefined, minArgumentCount, flags); } @@ -53965,13 +54599,16 @@ var ts; return false; switch (node.kind) { case 78 /* Identifier */: - return node.escapedText === "arguments" && ts.isExpressionNode(node); + return node.escapedText === argumentsSymbol.escapedName && getResolvedSymbol(node) === argumentsSymbol; case 163 /* PropertyDeclaration */: case 165 /* MethodDeclaration */: case 167 /* GetAccessor */: case 168 /* SetAccessor */: return node.name.kind === 158 /* ComputedPropertyName */ && traverse(node.name); + case 201 /* PropertyAccessExpression */: + case 202 /* ElementAccessExpression */: + return traverse(node.expression); default: return !ts.nodeStartsNewLexicalEnvironment(node) && !ts.isPartOfTypeNode(node) && !!ts.forEachChild(node, traverse); } @@ -54052,13 +54689,13 @@ var ts; return errorType; } var type = signature.target ? instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper) : - signature.unionSignatures ? getUnionType(ts.map(signature.unionSignatures, getReturnTypeOfSignature), 2 /* Subtype */) : + signature.unionSignatures ? instantiateType(getUnionType(ts.map(signature.unionSignatures, getReturnTypeOfSignature), 2 /* Subtype */), signature.mapper) : getReturnTypeFromAnnotation(signature.declaration) || (ts.nodeIsMissing(signature.declaration.body) ? anyType : getReturnTypeFromBody(signature.declaration)); - if (signature.flags & 4 /* IsInnerCallChain */) { + if (signature.flags & 8 /* IsInnerCallChain */) { type = addOptionalTypeMarker(type); } - else if (signature.flags & 8 /* IsOuterCallChain */) { + else if (signature.flags & 16 /* IsOuterCallChain */) { type = getOptionalType(type); } if (!popTypeResolution()) { @@ -54095,7 +54732,7 @@ var ts; if (typeNode) { return getTypeFromTypeNode(typeNode); } - if (declaration.kind === 167 /* GetAccessor */ && !hasNonBindableDynamicName(declaration)) { + if (declaration.kind === 167 /* GetAccessor */ && hasBindableName(declaration)) { var jsDocType = ts.isInJSFile(declaration) && getTypeForDeclarationFromJSDocComment(declaration); if (jsDocType) { return jsDocType; @@ -54279,6 +54916,11 @@ var ts; else if (grandParent.kind === 194 /* TemplateLiteralTypeSpan */) { inferences = ts.append(inferences, stringType); } + // When an 'infer T' declaration is in the constraint position of a mapped type, we infer a 'keyof any' + // constraint. + else if (grandParent.kind === 159 /* TypeParameter */ && grandParent.parent.kind === 190 /* MappedType */) { + inferences = ts.append(inferences, keyofConstraintType); + } } } } @@ -54337,6 +54979,9 @@ var ts; } return result; } + function getAliasId(aliasSymbol, aliasTypeArguments) { + return aliasSymbol ? "@" + getSymbolId(aliasSymbol) + (aliasTypeArguments ? ":" + getTypeListId(aliasTypeArguments) : "") : ""; + } // This function is used to propagate certain flags when creating new object type references and union types. // It is only necessary to do so if a constituent type might be the undefined type, the null type, the type // of an object literal or the anyFunctionType. This is because there are operations in the type checker @@ -54371,15 +55016,18 @@ var ts; type.resolvedTypeArguments = source.resolvedTypeArguments; return type; } - function createDeferredTypeReference(target, node, mapper) { - var aliasSymbol = getAliasSymbolForTypeNode(node); - var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); + function createDeferredTypeReference(target, node, mapper, aliasSymbol, aliasTypeArguments) { + if (!aliasSymbol) { + aliasSymbol = getAliasSymbolForTypeNode(node); + var localAliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); + aliasTypeArguments = mapper ? instantiateTypes(localAliasTypeArguments, mapper) : localAliasTypeArguments; + } var type = createObjectType(4 /* Reference */, target.symbol); type.target = target; type.node = node; type.mapper = mapper; type.aliasSymbol = aliasSymbol; - type.aliasTypeArguments = mapper ? instantiateTypes(aliasTypeArguments, mapper) : aliasTypeArguments; + type.aliasTypeArguments = aliasTypeArguments; return type; } function getTypeArguments(type) { @@ -54444,17 +55092,17 @@ var ts; } return checkNoTypeArguments(node, symbol) ? type : errorType; } - function getTypeAliasInstantiation(symbol, typeArguments) { + function getTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) { var type = getDeclaredTypeOfSymbol(symbol); if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) { return getStringMappingType(symbol, typeArguments[0]); } var links = getSymbolLinks(symbol); var typeParameters = links.typeParameters; - var id = getTypeListId(typeArguments); + var id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments); var instantiation = links.instantiations.get(id); if (!instantiation) { - links.instantiations.set(id, instantiation = instantiateType(type, createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(symbol.valueDeclaration))))); + links.instantiations.set(id, instantiation = instantiateTypeWithAlias(type, createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(symbol.valueDeclaration))), aliasSymbol, aliasTypeArguments)); } return instantiation; } @@ -54475,7 +55123,8 @@ var ts; ts.Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments, symbolToString(symbol), minTypeArgumentCount, typeParameters.length); return errorType; } - return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node)); + var aliasSymbol = getAliasSymbolForTypeNode(node); + return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node), aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol)); } return checkNoTypeArguments(node, symbol) ? type : errorType; } @@ -54959,7 +55608,7 @@ var ts; // is true for each of the synthesized type parameters. function createTupleTargetType(elementFlags, readonly, namedMemberDeclarations) { var arity = elementFlags.length; - var minLength = ts.findLastIndex(elementFlags, function (f) { return !!(f & (1 /* Required */ | 8 /* Variadic */)); }) + 1; + var minLength = ts.countWhere(elementFlags, function (f) { return !!(f & (1 /* Required */ | 8 /* Variadic */)); }); var typeParameters; var properties = []; var combinedFlags = 0; @@ -55015,92 +55664,101 @@ var ts; return type; } function createNormalizedTypeReference(target, typeArguments) { - return target.objectFlags & 8 /* Tuple */ && target.combinedFlags & 8 /* Variadic */ ? - createNormalizedTupleType(target, typeArguments) : - createTypeReference(target, typeArguments); + return target.objectFlags & 8 /* Tuple */ ? createNormalizedTupleType(target, typeArguments) : createTypeReference(target, typeArguments); } function createNormalizedTupleType(target, elementTypes) { var _a, _b, _c; - // Transform [A, ...(X | Y | Z)] into [A, ...X] | [A, ...Y] | [A, ...Z] - var unionIndex = ts.findIndex(elementTypes, function (t, i) { return !!(target.elementFlags[i] & 8 /* Variadic */ && t.flags & (131072 /* Never */ | 1048576 /* Union */)); }); - if (unionIndex >= 0) { - return checkCrossProductUnion(ts.map(elementTypes, function (t, i) { return target.elementFlags[i] & 8 /* Variadic */ ? t : unknownType; })) ? - mapType(elementTypes[unionIndex], function (t) { return createNormalizedTupleType(target, ts.replaceElement(elementTypes, unionIndex, t)); }) : - errorType; - } - // If there are no variadic elements with non-generic types, just create a type reference with the same target type. - var spreadIndex = ts.findIndex(elementTypes, function (t, i) { return !!(target.elementFlags[i] & 8 /* Variadic */) && !(t.flags & 58982400 /* InstantiableNonPrimitive */) && !isGenericMappedType(t); }); - if (spreadIndex < 0) { + if (!(target.combinedFlags & 14 /* NonRequired */)) { + // No need to normalize when we only have regular required elements return createTypeReference(target, elementTypes); } - // We have non-generic variadic elements that need normalization. + if (target.combinedFlags & 8 /* Variadic */) { + // Transform [A, ...(X | Y | Z)] into [A, ...X] | [A, ...Y] | [A, ...Z] + var unionIndex_1 = ts.findIndex(elementTypes, function (t, i) { return !!(target.elementFlags[i] & 8 /* Variadic */ && t.flags & (131072 /* Never */ | 1048576 /* Union */)); }); + if (unionIndex_1 >= 0) { + return checkCrossProductUnion(ts.map(elementTypes, function (t, i) { return target.elementFlags[i] & 8 /* Variadic */ ? t : unknownType; })) ? + mapType(elementTypes[unionIndex_1], function (t) { return createNormalizedTupleType(target, ts.replaceElement(elementTypes, unionIndex_1, t)); }) : + errorType; + } + } + // We have optional, rest, or variadic elements that may need normalizing. Normalization ensures that all variadic + // elements are generic and that the tuple type has one of the following layouts, disregarding variadic elements: + // (1) Zero or more required elements, followed by zero or more optional elements, followed by zero or one rest element. + // (2) Zero or more required elements, followed by a rest element, followed by zero or more required elements. + // In either layout, zero or more generic variadic elements may be present at any location. var expandedTypes = []; var expandedFlags = []; var expandedDeclarations = []; - var optionalIndex = -1; - var restTypes; + var lastRequiredIndex = -1; + var firstRestIndex = -1; + var lastOptionalOrRestIndex = -1; var _loop_13 = function (i) { var type = elementTypes[i]; var flags = target.elementFlags[i]; if (flags & 8 /* Variadic */) { if (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type)) { - // Generic variadic elements stay as they are (except following a rest element). - addElementOrRest(type, 8 /* Variadic */, (_a = target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[i]); + // Generic variadic elements stay as they are. + addElement(type, 8 /* Variadic */, (_a = target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[i]); } else if (isTupleType(type)) { + var elements = getTypeArguments(type); + if (elements.length + expandedTypes.length >= 10000) { + error(currentNode, ts.isPartOfTypeNode(currentNode) + ? ts.Diagnostics.Type_produces_a_tuple_type_that_is_too_large_to_represent + : ts.Diagnostics.Expression_produces_a_tuple_type_that_is_too_large_to_represent); + return { value: errorType }; + } // Spread variadic elements with tuple types into the resulting tuple. - ts.forEach(getTypeArguments(type), function (t, n) { var _a; return addElementOrRest(t, type.target.elementFlags[n], (_a = type.target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[n]); }); + ts.forEach(elements, function (t, n) { var _a; return addElement(t, type.target.elementFlags[n], (_a = type.target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[n]); }); } else { // Treat everything else as an array type and create a rest element. - addElementOrRest(isArrayLikeType(type) && getIndexTypeOfType(type, 1 /* Number */) || errorType, 4 /* Rest */, (_b = target.labeledElementDeclarations) === null || _b === void 0 ? void 0 : _b[i]); + addElement(isArrayLikeType(type) && getIndexTypeOfType(type, 1 /* Number */) || errorType, 4 /* Rest */, (_b = target.labeledElementDeclarations) === null || _b === void 0 ? void 0 : _b[i]); } } else { // Copy other element kinds with no change. - addElementOrRest(type, flags, (_c = target.labeledElementDeclarations) === null || _c === void 0 ? void 0 : _c[i]); + addElement(type, flags, (_c = target.labeledElementDeclarations) === null || _c === void 0 ? void 0 : _c[i]); } }; for (var i = 0; i < elementTypes.length; i++) { - _loop_13(i); + var state_4 = _loop_13(i); + if (typeof state_4 === "object") + return state_4.value; } - if (restTypes) { - // Create a union of the collected rest element types. - expandedTypes[expandedTypes.length - 1] = getUnionType(restTypes); + // Turn optional elements preceding the last required element into required elements + for (var i = 0; i < lastRequiredIndex; i++) { + if (expandedFlags[i] & 2 /* Optional */) + expandedFlags[i] = 1 /* Required */; + } + if (firstRestIndex >= 0 && firstRestIndex < lastOptionalOrRestIndex) { + // Turn elements between first rest and last optional/rest into a single rest element + expandedTypes[firstRestIndex] = getUnionType(ts.sameMap(expandedTypes.slice(firstRestIndex, lastOptionalOrRestIndex + 1), function (t, i) { return expandedFlags[firstRestIndex + i] & 8 /* Variadic */ ? getIndexedAccessType(t, numberType) : t; })); + expandedTypes.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex); + expandedFlags.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex); + expandedDeclarations === null || expandedDeclarations === void 0 ? void 0 : expandedDeclarations.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex); } var tupleTarget = getTupleTargetType(expandedFlags, target.readonly, expandedDeclarations); return tupleTarget === emptyGenericType ? emptyObjectType : expandedFlags.length ? createTypeReference(tupleTarget, expandedTypes) : tupleTarget; - function addElementOrRest(type, flags, declaration) { - if (restTypes) { - // A rest element was previously added, so simply collect the type of this element. - restTypes.push(flags & 8 /* Variadic */ ? getIndexedAccessType(type, numberType) : type); + function addElement(type, flags, declaration) { + if (flags & 1 /* Required */) { + lastRequiredIndex = expandedFlags.length; + } + if (flags & 4 /* Rest */ && firstRestIndex < 0) { + firstRestIndex = expandedFlags.length; + } + if (flags & (2 /* Optional */ | 4 /* Rest */)) { + lastOptionalOrRestIndex = expandedFlags.length; + } + expandedTypes.push(type); + expandedFlags.push(flags); + if (expandedDeclarations && declaration) { + expandedDeclarations.push(declaration); } else { - if (flags & 1 /* Required */ && optionalIndex >= 0) { - // Turn preceding optional elements into required elements - for (var i = optionalIndex; i < expandedFlags.length; i++) { - if (expandedFlags[i] & 2 /* Optional */) - expandedFlags[i] = 1 /* Required */; - } - optionalIndex = -1; - } - else if (flags & 2 /* Optional */ && optionalIndex < 0) { - optionalIndex = expandedFlags.length; - } - else if (flags & 4 /* Rest */) { - // Start collecting element types when a rest element is added. - restTypes = [type]; - } - expandedTypes.push(type); - expandedFlags.push(flags); - if (expandedDeclarations && declaration) { - expandedDeclarations.push(declaration); - } - else { - expandedDeclarations = undefined; - } + expandedDeclarations = undefined; } } } @@ -55115,6 +55773,15 @@ var ts; function getKnownKeysOfTupleType(type) { return getUnionType(ts.append(ts.arrayOf(type.target.fixedLength, function (i) { return getLiteralType("" + i); }), getIndexType(type.target.readonly ? globalReadonlyArrayType : globalArrayType))); } + // Return count of starting consecutive tuple elements of the given kind(s) + function getStartElementCount(type, flags) { + var index = ts.findIndex(type.elementFlags, function (f) { return !(f & flags); }); + return index >= 0 ? index : type.elementFlags.length; + } + // Return count of ending consecutive tuple elements of the given kind(s) + function getEndElementCount(type, flags) { + return type.elementFlags.length - ts.findLastIndex(type.elementFlags, function (f) { return !(f & flags); }) - 1; + } function getTypeFromOptionalTypeNode(node) { var type = getTypeFromTypeNode(node.type); return strictNullChecks ? getOptionalType(type) : type; @@ -55136,7 +55803,7 @@ var ts; function addTypeToUnion(typeSet, includes, type) { var flags = type.flags; if (flags & 1048576 /* Union */) { - return addTypesToUnion(typeSet, includes, type.types); + return addTypesToUnion(typeSet, includes | (isNamedUnionType(type) ? 1048576 /* Union */ : 0), type.types); } // We ignore 'never' types in unions if (!(flags & 131072 /* Never */)) { @@ -55168,67 +55835,57 @@ var ts; } return includes; } - function isSetOfLiteralsFromSameEnum(types) { - var first = types[0]; - if (first.flags & 1024 /* EnumLiteral */) { - var firstEnum = getParentOfSymbol(first.symbol); - for (var i = 1; i < types.length; i++) { - var other = types[i]; - if (!(other.flags & 1024 /* EnumLiteral */) || (firstEnum !== getParentOfSymbol(other.symbol))) { - return false; - } - } - return true; - } - return false; - } - function removeSubtypes(types, primitivesOnly) { + function removeSubtypes(types, hasObjectTypes) { + // We assume that redundant primitive types have already been removed from the types array and that there + // are no any and unknown types in the array. Thus, the only possible supertypes for primitive types are empty + // object types, and if none of those are present we can exclude primitive types from the subtype check. + var hasEmptyObject = hasObjectTypes && ts.some(types, function (t) { return !!(t.flags & 524288 /* Object */) && !isGenericMappedType(t) && isEmptyResolvedType(resolveStructuredTypeMembers(t)); }); var len = types.length; - if (len === 0 || isSetOfLiteralsFromSameEnum(types)) { - return true; - } var i = len; var count = 0; while (i > 0) { i--; var source = types[i]; - for (var _i = 0, types_11 = types; _i < types_11.length; _i++) { - var target = types_11[_i]; - if (source !== target) { - if (count === 100000) { - // After 100000 subtype checks we estimate the remaining amount of work by assuming the - // same ratio of checks per element. If the estimated number of remaining type checks is - // greater than an upper limit we deem the union type too complex to represent. The - // upper limit is 25M for unions of primitives only, and 1M otherwise. This for example - // caps union types at 5000 unique literal types and 1000 unique object types. - var estimatedCount = (count / (len - i)) * len; - if (estimatedCount > (primitivesOnly ? 25000000 : 1000000)) { - ts.tracing.instant("check" /* Check */, "removeSubtypes_DepthLimit", { typeIds: types.map(function (t) { return t.id; }) }); - error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent); - return false; + if (hasEmptyObject || source.flags & 469499904 /* StructuredOrInstantiable */) { + for (var _i = 0, types_11 = types; _i < types_11.length; _i++) { + var target = types_11[_i]; + if (source !== target) { + if (count === 100000) { + // After 100000 subtype checks we estimate the remaining amount of work by assuming the + // same ratio of checks per element. If the estimated number of remaining type checks is + // greater than 1M we deem the union type too complex to represent. This for example + // caps union types at 1000 unique object types. + var estimatedCount = (count / (len - i)) * len; + if (estimatedCount > 1000000) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "removeSubtypes_DepthLimit", { typeIds: types.map(function (t) { return t.id; }) }); + error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent); + return false; + } + } + count++; + if (isTypeRelatedTo(source, target, strictSubtypeRelation) && (!(ts.getObjectFlags(getTargetType(source)) & 1 /* Class */) || + !(ts.getObjectFlags(getTargetType(target)) & 1 /* Class */) || + isTypeDerivedFrom(source, target))) { + ts.orderedRemoveItemAt(types, i); + break; } - } - count++; - if (isTypeRelatedTo(source, target, strictSubtypeRelation) && (!(ts.getObjectFlags(getTargetType(source)) & 1 /* Class */) || - !(ts.getObjectFlags(getTargetType(target)) & 1 /* Class */) || - isTypeDerivedFrom(source, target))) { - ts.orderedRemoveItemAt(types, i); - break; } } } } return true; } - function removeRedundantLiteralTypes(types, includes) { + function removeRedundantLiteralTypes(types, includes, reduceVoidUndefined) { var i = types.length; while (i > 0) { i--; var t = types[i]; - var remove = t.flags & 128 /* StringLiteral */ && includes & 4 /* String */ || - t.flags & 256 /* NumberLiteral */ && includes & 8 /* Number */ || - t.flags & 2048 /* BigIntLiteral */ && includes & 64 /* BigInt */ || - t.flags & 8192 /* UniqueESSymbol */ && includes & 4096 /* ESSymbol */ || + var flags = t.flags; + var remove = flags & 128 /* StringLiteral */ && includes & 4 /* String */ || + flags & 256 /* NumberLiteral */ && includes & 8 /* Number */ || + flags & 2048 /* BigIntLiteral */ && includes & 64 /* BigInt */ || + flags & 8192 /* UniqueESSymbol */ && includes & 4096 /* ESSymbol */ || + reduceVoidUndefined && flags & 32768 /* Undefined */ && includes & 16384 /* Void */ || isFreshLiteralType(t) && containsType(types, t.regularType); if (remove) { ts.orderedRemoveItemAt(types, i); @@ -55251,6 +55908,28 @@ var ts; } } } + function isNamedUnionType(type) { + return !!(type.flags & 1048576 /* Union */ && (type.aliasSymbol || type.origin)); + } + function addNamedUnions(namedUnions, types) { + for (var _i = 0, types_12 = types; _i < types_12.length; _i++) { + var t = types_12[_i]; + if (t.flags & 1048576 /* Union */) { + var origin = t.origin; + if (t.aliasSymbol || origin && !(origin.flags & 1048576 /* Union */)) { + ts.pushIfUnique(namedUnions, t); + } + else if (origin && origin.flags & 1048576 /* Union */) { + addNamedUnions(namedUnions, origin.types); + } + } + } + } + function createOriginUnionOrIntersectionType(flags, types) { + var result = createOriginType(flags); + result.types = types; + return result; + } // We sort and deduplicate the constituent types based on object identity. If the subtypeReduction // flag is specified we also reduce the constituent type set to only include types that aren't subtypes // of other types. Subtype reduction is expensive for large union types and is possible only when union @@ -55258,7 +55937,7 @@ var ts; // expression constructs such as array literals and the || and ?: operators). Named types can // circularly reference themselves and therefore cannot be subtype reduced during their declaration. // For example, "type Item = string | (() => Item" is a named type that circularly references itself. - function getUnionType(types, unionReduction, aliasSymbol, aliasTypeArguments) { + function getUnionType(types, unionReduction, aliasSymbol, aliasTypeArguments, origin) { if (unionReduction === void 0) { unionReduction = 1 /* Literal */; } if (types.length === 0) { return neverType; @@ -55272,20 +55951,18 @@ var ts; if (includes & 3 /* AnyOrUnknown */) { return includes & 1 /* Any */ ? includes & 8388608 /* IncludesWildcard */ ? wildcardType : anyType : unknownType; } - switch (unionReduction) { - case 1 /* Literal */: - if (includes & (2944 /* Literal */ | 8192 /* UniqueESSymbol */)) { - removeRedundantLiteralTypes(typeSet, includes); - } - if (includes & 128 /* StringLiteral */ && includes & 134217728 /* TemplateLiteral */) { - removeStringLiteralsMatchedByTemplateLiterals(typeSet); - } - break; - case 2 /* Subtype */: - if (!removeSubtypes(typeSet, !(includes & 262144 /* IncludesStructuredOrInstantiable */))) { - return errorType; - } - break; + if (unionReduction & (1 /* Literal */ | 2 /* Subtype */)) { + if (includes & (2944 /* Literal */ | 8192 /* UniqueESSymbol */) || includes & 16384 /* Void */ && includes & 32768 /* Undefined */) { + removeRedundantLiteralTypes(typeSet, includes, !!(unionReduction & 2 /* Subtype */)); + } + if (includes & 128 /* StringLiteral */ && includes & 134217728 /* TemplateLiteral */) { + removeStringLiteralsMatchedByTemplateLiterals(typeSet); + } + } + if (unionReduction & 2 /* Subtype */) { + if (!removeSubtypes(typeSet, !!(includes & 524288 /* Object */))) { + return errorType; + } } if (typeSet.length === 0) { return includes & 65536 /* Null */ ? includes & 4194304 /* IncludesNonWideningType */ ? nullType : nullWideningType : @@ -55293,9 +55970,36 @@ var ts; neverType; } } - var objectFlags = (includes & 469647395 /* NotPrimitiveUnion */ ? 0 : 262144 /* PrimitiveUnion */) | + if (!origin && includes & 1048576 /* Union */) { + var namedUnions = []; + addNamedUnions(namedUnions, types); + var reducedTypes = []; + var _loop_15 = function (t) { + if (!ts.some(namedUnions, function (union) { return containsType(union.types, t); })) { + reducedTypes.push(t); + } + }; + for (var _i = 0, typeSet_1 = typeSet; _i < typeSet_1.length; _i++) { + var t = typeSet_1[_i]; + _loop_15(t); + } + if (!aliasSymbol && namedUnions.length === 1 && reducedTypes.length === 0) { + return namedUnions[0]; + } + // We create a denormalized origin type only when the union was created from one or more named unions + // (unions with alias symbols or origins) and when there is no overlap between those named unions. + var namedTypesCount = ts.reduceLeft(namedUnions, function (sum, union) { return sum + union.types.length; }, 0); + if (namedTypesCount + reducedTypes.length === typeSet.length) { + for (var _a = 0, namedUnions_1 = namedUnions; _a < namedUnions_1.length; _a++) { + var t = namedUnions_1[_a]; + insertType(reducedTypes, t); + } + origin = createOriginUnionOrIntersectionType(1048576 /* Union */, reducedTypes); + } + } + var objectFlags = (includes & 468598819 /* NotPrimitiveUnion */ ? 0 : 262144 /* PrimitiveUnion */) | (includes & 2097152 /* Intersection */ ? 268435456 /* ContainsIntersections */ : 0); - return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments); + return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin); } function getUnionTypePredicate(signatures) { var first; @@ -55327,29 +56031,33 @@ var ts; function typePredicateKindsMatch(a, b) { return a.kind === b.kind && a.parameterIndex === b.parameterIndex; } + function createUnionType(types, aliasSymbol, aliasTypeArguments, origin) { + var result = createType(1048576 /* Union */); + result.objectFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ 98304 /* Nullable */); + result.types = types; + result.origin = origin; + result.aliasSymbol = aliasSymbol; + result.aliasTypeArguments = aliasTypeArguments; + return result; + } // This function assumes the constituent type list is sorted and deduplicated. - function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments) { + function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments, origin) { if (types.length === 0) { return neverType; } if (types.length === 1) { return types[0]; } - var id = getTypeListId(types); + var typeKey = !origin ? getTypeListId(types) : + origin.flags & 1048576 /* Union */ ? "|" + getTypeListId(origin.types) : + origin.flags & 2097152 /* Intersection */ ? "&" + getTypeListId(origin.types) : + "#" + origin.type.id; + var id = typeKey + getAliasId(aliasSymbol, aliasTypeArguments); var type = unionTypes.get(id); if (!type) { - type = createType(1048576 /* Union */); + type = createUnionType(types, aliasSymbol, aliasTypeArguments, origin); + type.objectFlags |= objectFlags; unionTypes.set(id, type); - type.objectFlags = objectFlags | getPropagatingFlagsOfTypes(types, /*excludeKinds*/ 98304 /* Nullable */); - type.types = types; - /* - Note: This is the alias symbol (or lack thereof) that we see when we first encounter this union type. - For aliases of identical unions, eg `type T = A | B; type U = A | B`, the symbol of the first alias encountered is the aliasSymbol. - (In the language service, the order may depend on the order in which a user takes actions, such as hovering over symbols.) - It's important that we create equivalent union types only once, so that's an unfortunate side effect. - */ - type.aliasSymbol = aliasSymbol; - type.aliasTypeArguments = aliasTypeArguments; } return type; } @@ -55392,8 +56100,8 @@ var ts; // Add the given types to the given type set. Order is preserved, freshness is removed from literal // types, duplicates are removed, and nested types of the given kind are flattened into the set. function addTypesToIntersection(typeSet, includes, types) { - for (var _i = 0, types_12 = types; _i < types_12.length; _i++) { - var type = types_12[_i]; + for (var _i = 0, types_13 = types; _i < types_13.length; _i++) { + var type = types_13[_i]; includes = addTypeToIntersection(typeSet, includes, getRegularTypeOfLiteralType(type)); } return includes; @@ -55515,7 +56223,7 @@ var ts; var result = createType(2097152 /* Intersection */); result.objectFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ 98304 /* Nullable */); result.types = types; - result.aliasSymbol = aliasSymbol; // See comment in `getUnionTypeFromSortedList`. + result.aliasSymbol = aliasSymbol; result.aliasTypeArguments = aliasTypeArguments; return result; } @@ -55576,7 +56284,7 @@ var ts; if (typeSet.length === 1) { return typeSet[0]; } - var id = getTypeListId(typeSet); + var id = getTypeListId(typeSet) + getAliasId(aliasSymbol, aliasTypeArguments); var result = intersectionTypes.get(id); if (!result) { if (includes & 1048576 /* Union */) { @@ -55593,15 +56301,17 @@ var ts; result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments); } else { - // We are attempting to construct a type of the form X & (A | B) & Y. Transform this into a type of - // the form X & A & Y | X & B & Y and recursively reduce until no union type constituents remain. - // If the estimated size of the resulting union type exceeds 100000 constituents, report an error. + // We are attempting to construct a type of the form X & (A | B) & (C | D). Transform this into a type of + // the form X & A & C | X & A & D | X & B & C | X & B & D. If the estimated size of the resulting union type + // exceeds 100000 constituents, report an error. if (!checkCrossProductUnion(typeSet)) { return errorType; } - var unionIndex_1 = ts.findIndex(typeSet, function (t) { return (t.flags & 1048576 /* Union */) !== 0; }); - var unionType = typeSet[unionIndex_1]; - result = getUnionType(ts.map(unionType.types, function (t) { return getIntersectionType(ts.replaceElement(typeSet, unionIndex_1, t)); }), 1 /* Literal */, aliasSymbol, aliasTypeArguments); + var constituents = getCrossProductIntersections(typeSet); + // We attach a denormalized origin type when at least one constituent of the cross-product union is an + // intersection (i.e. when the intersection didn't just reduce one or more unions to smaller unions). + var origin = ts.some(constituents, function (t) { return !!(t.flags & 2097152 /* Intersection */); }) ? createOriginUnionOrIntersectionType(2097152 /* Intersection */, typeSet) : undefined; + result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin); } } else { @@ -55611,15 +56321,38 @@ var ts; } return result; } + function getCrossProductUnionSize(types) { + return ts.reduceLeft(types, function (n, t) { return t.flags & 1048576 /* Union */ ? n * t.types.length : t.flags & 131072 /* Never */ ? 0 : n; }, 1); + } function checkCrossProductUnion(types) { - var size = ts.reduceLeft(types, function (n, t) { return n * (t.flags & 1048576 /* Union */ ? t.types.length : t.flags & 131072 /* Never */ ? 0 : 1); }, 1); + var size = getCrossProductUnionSize(types); if (size >= 100000) { - ts.tracing.instant("check" /* Check */, "checkCrossProductUnion_DepthLimit", { typeIds: types.map(function (t) { return t.id; }), size: size }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "checkCrossProductUnion_DepthLimit", { typeIds: types.map(function (t) { return t.id; }), size: size }); error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent); return false; } return true; } + function getCrossProductIntersections(types) { + var count = getCrossProductUnionSize(types); + var intersections = []; + for (var i = 0; i < count; i++) { + var constituents = types.slice(); + var n = i; + for (var j = types.length - 1; j >= 0; j--) { + if (types[j].flags & 1048576 /* Union */) { + var sourceTypes = types[j].types; + var length_5 = sourceTypes.length; + constituents[j] = sourceTypes[n % length_5]; + n = Math.floor(n / length_5); + } + } + var t = getIntersectionType(constituents); + if (!(t.flags & 131072 /* Never */)) + intersections.push(t); + } + return intersections; + } function getTypeFromIntersectionTypeNode(node) { var links = getNodeLinks(node); if (!links.resolvedType) { @@ -55634,28 +56367,39 @@ var ts; result.stringsOnly = stringsOnly; return result; } + function createOriginIndexType(type) { + var result = createOriginType(4194304 /* Index */); + result.type = type; + return result; + } function getIndexTypeForGenericType(type, stringsOnly) { return stringsOnly ? type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(type, /*stringsOnly*/ true)) : type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, /*stringsOnly*/ false)); } + function instantiateTypeAsMappedNameType(nameType, type, t) { + return instantiateType(nameType, appendTypeMapping(type.mapper, getTypeParameterFromMappedType(type), t)); + } function getIndexTypeForMappedType(type, noIndexSignatures) { var constraint = filterType(getConstraintTypeFromMappedType(type), function (t) { return !(noIndexSignatures && t.flags & (1 /* Any */ | 4 /* String */)); }); var nameType = type.declaration.nameType && getTypeFromTypeNode(type.declaration.nameType); + // If the constraint is exclusively string/number/never type(s), we need to pull the property names from the modified type and run them through the `nameType` mapper as well + // since they won't appear in the constraint, due to subtype reducing with the string/number index types + var properties = nameType && everyType(constraint, function (t) { return !!(t.flags & (4 /* String */ | 8 /* Number */ | 131072 /* Never */)); }) && getPropertiesOfType(getApparentType(getModifiersTypeFromMappedType(type))); return nameType ? - mapType(constraint, function (t) { return instantiateType(nameType, appendTypeMapping(type.mapper, getTypeParameterFromMappedType(type), t)); }) : + getUnionType([mapType(constraint, function (t) { return instantiateTypeAsMappedNameType(nameType, type, t); }), mapType(getUnionType(ts.map(properties || ts.emptyArray, function (p) { return getLiteralTypeFromProperty(p, 8576 /* StringOrNumberLiteralOrUnique */); })), function (t) { return instantiateTypeAsMappedNameType(nameType, type, t); })]) : constraint; } - // Ordinarily we reduce a keyof M where M is a mapped type { [P in K as N

]: X } to simply N. This however presumes - // that N distributes over union types, i.e. that N is equivalent to N | N | N. That presumption is - // generally true, except when N is a non-distributive conditional type or an instantiable type with non-distributive - // conditional type as a constituent. In those cases, we cannot reduce keyof M and need to preserve it as is. - function isNonDistributiveNameType(type) { - return !!(type && (type.flags & 16777216 /* Conditional */ && !type.root.isDistributive || - type.flags & (3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */) && ts.some(type.types, isNonDistributiveNameType) || - type.flags & (4194304 /* Index */ | 268435456 /* StringMapping */) && isNonDistributiveNameType(type.type) || - type.flags & 8388608 /* IndexedAccess */ && isNonDistributiveNameType(type.indexType) || - type.flags & 33554432 /* Substitution */ && isNonDistributiveNameType(type.substitute))); + // Ordinarily we reduce a keyof M, where M is a mapped type { [P in K as N

]: X }, to simply N. This however presumes + // that N distributes over union types, i.e. that N is equivalent to N | N | N. That presumption may not + // be true when N is a non-distributive conditional type or an instantiable type with a non-distributive conditional type as + // a constituent. In those cases, we cannot reduce keyof M and need to preserve it as is. + function maybeNonDistributiveNameType(type) { + return !!(type && (type.flags & 16777216 /* Conditional */ && (!type.root.isDistributive || maybeNonDistributiveNameType(type.checkType)) || + type.flags & (3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */) && ts.some(type.types, maybeNonDistributiveNameType) || + type.flags & (4194304 /* Index */ | 268435456 /* StringMapping */) && maybeNonDistributiveNameType(type.type) || + type.flags & 8388608 /* IndexedAccess */ && maybeNonDistributiveNameType(type.indexType) || + type.flags & 33554432 /* Substitution */ && maybeNonDistributiveNameType(type.substitute))); } function getLiteralTypeFromPropertyName(name) { if (ts.isPrivateIdentifier(name)) { @@ -55688,8 +56432,10 @@ var ts; } return neverType; } - function getLiteralTypeFromProperties(type, include) { - return getUnionType(ts.map(getPropertiesOfType(type), function (p) { return getLiteralTypeFromProperty(p, include); })); + function getLiteralTypeFromProperties(type, include, includeOrigin) { + var origin = includeOrigin && (ts.getObjectFlags(type) & (3 /* ClassOrInterface */ | 4 /* Reference */) || type.aliasSymbol) ? createOriginIndexType(type) : undefined; + return getUnionType(ts.map(getPropertiesOfType(type), function (p) { return getLiteralTypeFromProperty(p, include); }), 1 /* Literal */, + /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, origin); } function getNonEnumNumberIndexInfo(type) { var numberIndexInfo = getIndexInfoOfType(type, 1 /* Number */); @@ -55697,18 +56443,19 @@ var ts; } function getIndexType(type, stringsOnly, noIndexSignatures) { if (stringsOnly === void 0) { stringsOnly = keyofStringsOnly; } + var includeOrigin = stringsOnly === keyofStringsOnly && !noIndexSignatures; type = getReducedType(type); return type.flags & 1048576 /* Union */ ? getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) : type.flags & 2097152 /* Intersection */ ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) : - type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && isNonDistributiveNameType(getNameTypeFromMappedType(type)) ? getIndexTypeForGenericType(type, stringsOnly) : + type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && maybeNonDistributiveNameType(getNameTypeFromMappedType(type)) ? getIndexTypeForGenericType(type, stringsOnly) : ts.getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, noIndexSignatures) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : - stringsOnly ? !noIndexSignatures && getIndexInfoOfType(type, 0 /* String */) ? stringType : getLiteralTypeFromProperties(type, 128 /* StringLiteral */) : - !noIndexSignatures && getIndexInfoOfType(type, 0 /* String */) ? getUnionType([stringType, numberType, getLiteralTypeFromProperties(type, 8192 /* UniqueESSymbol */)]) : - getNonEnumNumberIndexInfo(type) ? getUnionType([numberType, getLiteralTypeFromProperties(type, 128 /* StringLiteral */ | 8192 /* UniqueESSymbol */)]) : - getLiteralTypeFromProperties(type, 8576 /* StringOrNumberLiteralOrUnique */); + stringsOnly ? !noIndexSignatures && getIndexInfoOfType(type, 0 /* String */) ? stringType : getLiteralTypeFromProperties(type, 128 /* StringLiteral */, includeOrigin) : + !noIndexSignatures && getIndexInfoOfType(type, 0 /* String */) ? getUnionType([stringType, numberType, getLiteralTypeFromProperties(type, 8192 /* UniqueESSymbol */, includeOrigin)]) : + getNonEnumNumberIndexInfo(type) ? getUnionType([numberType, getLiteralTypeFromProperties(type, 128 /* StringLiteral */ | 8192 /* UniqueESSymbol */, includeOrigin)]) : + getLiteralTypeFromProperties(type, 8576 /* StringOrNumberLiteralOrUnique */, includeOrigin); } function getExtractStringType(type) { if (keyofStringsOnly) { @@ -55745,7 +56492,7 @@ var ts; function getTypeFromTemplateTypeNode(node) { var links = getNodeLinks(node); if (!links.resolvedType) { - links.resolvedType = getTemplateLiteralType(__spreadArrays([node.head.text], ts.map(node.templateSpans, function (span) { return span.literal.text; })), ts.map(node.templateSpans, function (span) { return getTypeFromTypeNode(span.type); })); + links.resolvedType = getTemplateLiteralType(__spreadArray([node.head.text], ts.map(node.templateSpans, function (span) { return span.literal.text; })), ts.map(node.templateSpans, function (span) { return getTypeFromTypeNode(span.type); })); } return links.resolvedType; } @@ -55769,6 +56516,9 @@ var ts; return getLiteralType(text); } newTexts.push(text); + if (ts.every(newTexts, function (t) { return t === ""; }) && ts.every(newTypes, function (t) { return !!(t.flags & 4 /* String */); })) { + return stringType; + } var id = getTypeListId(newTypes) + "|" + ts.map(newTexts, function (t) { return t.length; }).join(",") + "|" + newTexts.join(""); var type = templateLiteralTypes.get(id); if (!type) { @@ -55876,7 +56626,8 @@ var ts; return ts.some(type.types, isJSLiteralType); } if (type.flags & 465829888 /* Instantiable */) { - return isJSLiteralType(getResolvedBaseConstraint(type)); + var constraint = getResolvedBaseConstraint(type); + return constraint !== type && isJSLiteralType(constraint); } return false; } @@ -55892,9 +56643,14 @@ var ts; undefined; } function isUncalledFunctionReference(node, symbol) { - return !(symbol.flags & (16 /* Function */ | 8192 /* Method */)) - || !ts.isCallLikeExpression(ts.findAncestor(node, function (n) { return !ts.isAccessExpression(n); }) || node.parent) - && ts.every(symbol.declarations, function (d) { return !ts.isFunctionLike(d) || !!(ts.getCombinedNodeFlags(d) & 134217728 /* Deprecated */); }); + if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) { + var parent = ts.findAncestor(node.parent, function (n) { return !ts.isAccessExpression(n); }) || node.parent; + if (ts.isCallLikeExpression(parent)) { + return ts.isCallOrNewExpression(parent) && ts.isIdentifier(node) && hasMatchingArgument(parent, node); + } + return ts.every(symbol.declarations, function (d) { return !ts.isFunctionLike(d) || !!(ts.getCombinedNodeFlags(d) & 134217728 /* Deprecated */); }); + } + return true; } function getPropertyTypeForIndexType(originalObjectType, objectType, indexType, fullIndexType, suppressNoImplicitAnyError, accessNode, accessFlags, noUncheckedIndexedAccessCandidate, reportDeprecated) { var _a; @@ -55905,7 +56661,7 @@ var ts; if (prop) { if (reportDeprecated && accessNode && getDeclarationNodeFlagsFromSymbol(prop) & 134217728 /* Deprecated */ && isUncalledFunctionReference(accessNode, prop)) { var deprecatedNode = (_a = accessExpression === null || accessExpression === void 0 ? void 0 : accessExpression.argumentExpression) !== null && _a !== void 0 ? _a : (ts.isIndexedAccessTypeNode(accessNode) ? accessNode.indexType : accessNode); - errorOrSuggestion(/* isError */ false, deprecatedNode, ts.Diagnostics._0_is_deprecated, propName); + addDeprecatedSuggestion(deprecatedNode, prop.declarations, propName); } if (accessExpression) { markPropertyAsReferenced(prop, accessExpression, /*isThisAccess*/ accessExpression.expression.kind === 107 /* ThisKeyword */); @@ -55970,12 +56726,25 @@ var ts; return anyType; } if (accessExpression && !isConstEnumObjectType(objectType)) { + if (isObjectLiteralType(objectType)) { + if (noImplicitAny && indexType.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) { + diagnostics.add(ts.createDiagnosticForNode(accessExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType))); + return undefinedType; + } + else if (indexType.flags & (8 /* Number */ | 4 /* String */)) { + var types = ts.map(objectType.properties, function (property) { + return getTypeOfSymbol(property); + }); + return getUnionType(ts.append(types, undefinedType)); + } + } if (objectType.symbol === globalThisSymbol && propName !== undefined && globalThisSymbol.exports.has(propName) && (globalThisSymbol.exports.get(propName).flags & 418 /* BlockScoped */)) { error(accessExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(propName), typeToString(objectType)); } else if (noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && !suppressNoImplicitAnyError) { if (propName !== undefined && typeHasStaticProperty(propName, objectType)) { - error(accessExpression, ts.Diagnostics.Property_0_is_a_static_member_of_type_1, propName, typeToString(objectType)); + var typeName = typeToString(objectType); + error(accessExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead, propName, typeName, typeName + "[" + ts.getTextOfNode(accessExpression.argumentExpression) + "]"); } else if (getIndexTypeOfType(objectType, 1 /* Number */)) { error(accessExpression.argumentExpression, ts.Diagnostics.Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number); @@ -56101,12 +56870,6 @@ var ts; return writing ? getIntersectionType(types) : getUnionType(types); } } - function unwrapSubstitution(type) { - if (type.flags & 33554432 /* Substitution */) { - return type.substitute; - } - return type; - } // Transform an indexed access to a simpler form, if possible. Return the simpler form, or return // the type itself if no transformation is possible. The writing flag indicates that the type is // the target of an assignment. @@ -56118,7 +56881,7 @@ var ts; type[cache] = circularConstraintType; // We recursively simplify the object type as it may in turn be an indexed access type. For example, with // '{ [P in T]: { [Q in U]: number } }[T][U]' we want to first simplify the inner indexed access type. - var objectType = unwrapSubstitution(getSimplifiedType(type.objectType, writing)); + var objectType = getSimplifiedType(type.objectType, writing); var indexType = getSimplifiedType(type.indexType, writing); // T[A | B] -> T[A] | T[B] (reading) // T[A | B] -> T[A] & T[B] (writing) @@ -56232,7 +56995,7 @@ var ts; return objectType; } // Defer the operation by creating an indexed access type. - var id = objectType.id + "," + indexType.id + (shouldIncludeUndefined ? "?" : ""); + var id = objectType.id + "," + indexType.id + (shouldIncludeUndefined ? "?" : "") + getAliasId(aliasSymbol, aliasTypeArguments); var type = indexedAccessTypes.get(id); if (!type) { indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType, aliasSymbol, aliasTypeArguments, shouldIncludeUndefined)); @@ -56308,24 +57071,39 @@ var ts; } return type; } - function getConditionalType(root, mapper) { + function isTypicalNondistributiveConditional(root) { + return !root.isDistributive + && root.node.checkType.kind === 179 /* TupleType */ + && ts.length(root.node.checkType.elements) === 1 + && root.node.extendsType.kind === 179 /* TupleType */ + && ts.length(root.node.extendsType.elements) === 1; + } + /** + * We syntactually check for common nondistributive conditional shapes and unwrap them into + * the intended comparison - we do this so we can check if the unwrapped types are generic or + * not and appropriately defer condition calculation + */ + function unwrapNondistributiveConditionalTuple(root, type) { + return isTypicalNondistributiveConditional(root) && isTupleType(type) ? getTypeArguments(type)[0] : type; + } + function getConditionalType(root, mapper, aliasSymbol, aliasTypeArguments) { var result; var extraTypes; - var _loop_15 = function () { - var checkType = instantiateType(root.checkType, mapper); + // We loop here for an immediately nested conditional type in the false position, effectively treating + // types of the form 'A extends B ? X : C extends D ? Y : E extends F ? Z : ...' as a single construct for + // purposes of resolution. This means such types aren't subject to the instatiation depth limiter. + while (true) { + var isUnwrapped = isTypicalNondistributiveConditional(root); + var checkType = instantiateType(unwrapNondistributiveConditionalTuple(root, root.checkType), mapper); var checkTypeInstantiable = isGenericObjectType(checkType) || isGenericIndexType(checkType); - var extendsType = instantiateType(root.extendsType, mapper); + var extendsType = instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), mapper); if (checkType === wildcardType || extendsType === wildcardType) { - return { value: wildcardType }; + return wildcardType; } var combinedMapper = void 0; if (root.inferTypeParameters) { var context = createInferenceContext(root.inferTypeParameters, /*signature*/ undefined, 0 /* None */); - // We skip inference of the possible `infer` types unles the `extendsType` _is_ an infer type - // if it was, it's trivial to say that extendsType = checkType, however such a pattern is used to - // "reset" the type being build up during constraint calculation and avoid making an apparently "infinite" constraint - // so in those cases we refain from performing inference and retain the uninfered type parameter - if (!checkTypeInstantiable || !ts.some(root.inferTypeParameters, function (t) { return t === extendsType; })) { + if (!checkTypeInstantiable) { // We don't want inferences from constraints as they may cause us to eagerly resolve the // conditional type instead of deferring resolution. Also, we always want strict function // types rules (i.e. proper contravariance) for inferences. @@ -56334,16 +57112,16 @@ var ts; combinedMapper = mergeTypeMappers(mapper, context.mapper); } // Instantiate the extends type including inferences for 'infer T' type parameters - var inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType; + var inferredExtendsType = combinedMapper ? instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), combinedMapper) : extendsType; // We attempt to resolve the conditional type only when the check and extends types are non-generic if (!checkTypeInstantiable && !isGenericObjectType(inferredExtendsType) && !isGenericIndexType(inferredExtendsType)) { // Return falseType for a definitely false extends check. We check an instantiations of the two // types with type parameters mapped to the wildcard type, the most permissive instantiations // possible (the wildcard type is assignable to and from all types). If those are not related, // then no instantiations will be and we can just return the false branch type. - if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) { + if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && ((checkType.flags & 1 /* Any */ && !isUnwrapped) || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) { // Return union of trueType and falseType for 'any' since it matches anything - if (checkType.flags & 1 /* Any */) { + if (checkType.flags & 1 /* Any */ && !isUnwrapped) { (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper)); } // If falseType is an immediately nested conditional type that isn't distributive or has an @@ -56353,11 +57131,11 @@ var ts; var newRoot = falseType_1.root; if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) { root = newRoot; - return "continue"; + continue; } } result = instantiateType(falseType_1, mapper); - return "break"; + break; } // Return trueType for a definitely true extends check. We check instantiations of the two // types with type parameters mapped to their restrictive form, i.e. a form of the type parameter @@ -56366,30 +57144,19 @@ var ts; // doesn't immediately resolve to 'string' instead of being deferred. if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) { result = instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper); - return "break"; + break; } } // Return a deferred type for a check that is neither definitely true nor definitely false - var erasedCheckType = getActualTypeVariable(checkType); result = createType(16777216 /* Conditional */); result.root = root; - result.checkType = erasedCheckType; - result.extendsType = extendsType; + result.checkType = instantiateType(root.checkType, mapper); + result.extendsType = instantiateType(root.extendsType, mapper); result.mapper = mapper; result.combinedMapper = combinedMapper; - result.aliasSymbol = root.aliasSymbol; - result.aliasTypeArguments = instantiateTypes(root.aliasTypeArguments, mapper); // TODO: GH#18217 - return "break"; - }; - // We loop here for an immediately nested conditional type in the false position, effectively treating - // types of the form 'A extends B ? X : C extends D ? Y : E extends F ? Z : ...' as a single construct for - // purposes of resolution. This means such types aren't subject to the instatiation depth limiter. - while (true) { - var state_4 = _loop_15(); - if (typeof state_4 === "object") - return state_4.value; - if (state_4 === "break") - break; + result.aliasSymbol = aliasSymbol || root.aliasSymbol; + result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root.aliasTypeArguments, mapper); // TODO: GH#18217 + break; } return extraTypes ? getUnionType(ts.append(extraTypes, result)) : result; } @@ -56562,19 +57329,18 @@ var ts; return isEmptyObjectType(type) || !!(type.flags & (65536 /* Null */ | 32768 /* Undefined */ | 528 /* BooleanLike */ | 296 /* NumberLike */ | 2112 /* BigIntLike */ | 402653316 /* StringLike */ | 1056 /* EnumLike */ | 67108864 /* NonPrimitive */ | 4194304 /* Index */)); } function tryMergeUnionOfObjectTypeAndEmptyObject(type, readonly) { - if (type.types.length === 2) { - var firstType = type.types[0]; - var secondType = type.types[1]; - if (ts.every(type.types, isEmptyObjectTypeOrSpreadsIntoEmptyObject)) { - return isEmptyObjectType(firstType) ? firstType : isEmptyObjectType(secondType) ? secondType : emptyObjectType; - } - if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(firstType)) { - return getAnonymousPartialType(secondType); - } - if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(secondType)) { - return getAnonymousPartialType(firstType); - } + if (ts.every(type.types, isEmptyObjectTypeOrSpreadsIntoEmptyObject)) { + return ts.find(type.types, isEmptyObjectType) || emptyObjectType; } + var firstType = ts.find(type.types, function (t) { return !isEmptyObjectTypeOrSpreadsIntoEmptyObject(t); }); + if (!firstType) { + return undefined; + } + var secondType = firstType && ts.find(type.types, function (t) { return t !== firstType && !isEmptyObjectTypeOrSpreadsIntoEmptyObject(t); }); + if (secondType) { + return undefined; + } + return getAnonymousPartialType(firstType); function getAnonymousPartialType(type) { // gets the type as if it had been spread, but where everything in the spread is made optional var members = ts.createSymbolTable(); @@ -56586,8 +57352,8 @@ var ts; else if (isSpreadableProperty(prop)) { var isSetonlyAccessor = prop.flags & 65536 /* SetAccessor */ && !(prop.flags & 32768 /* GetAccessor */); var flags = 4 /* Property */ | 16777216 /* Optional */; - var result = createSymbol(flags, prop.escapedName, readonly ? 8 /* Readonly */ : 0); - result.type = isSetonlyAccessor ? undefinedType : getTypeOfSymbol(prop); + var result = createSymbol(flags, prop.escapedName, getIsLateCheckFlag(prop) | (readonly ? 8 /* Readonly */ : 0)); + result.type = isSetonlyAccessor ? undefinedType : getUnionType([getTypeOfSymbol(prop), undefinedType]); result.declarations = prop.declarations; result.nameType = getSymbolLinks(prop).nameType; result.syntheticOrigin = prop; @@ -56716,7 +57482,7 @@ var ts; return prop; } var flags = 4 /* Property */ | (prop.flags & 16777216 /* Optional */); - var result = createSymbol(flags, prop.escapedName, readonly ? 8 /* Readonly */ : 0); + var result = createSymbol(flags, prop.escapedName, getIsLateCheckFlag(prop) | (readonly ? 8 /* Readonly */ : 0)); result.type = isSetonlyAccessor ? undefinedType : getTypeOfSymbol(prop); result.declarations = prop.declarations; result.nameType = getSymbolLinks(prop).nameType; @@ -56746,7 +57512,7 @@ var ts; } function getRegularTypeOfLiteralType(type) { return type.flags & 2944 /* Literal */ ? type.regularType : - type.flags & 1048576 /* Union */ ? (type.regularType || (type.regularType = getUnionType(ts.sameMap(type.types, getRegularTypeOfLiteralType)))) : + type.flags & 1048576 /* Union */ ? (type.regularType || (type.regularType = mapType(type, getRegularTypeOfLiteralType))) : type; } function isFreshLiteralType(type) { @@ -57069,7 +57835,7 @@ var ts; // See GH#17600. var result = createSignature(signature.declaration, freshTypeParameters, signature.thisParameter && instantiateSymbol(signature.thisParameter, mapper), instantiateList(signature.parameters, mapper, instantiateSymbol), /*resolvedReturnType*/ undefined, - /*resolvedTypePredicate*/ undefined, signature.minArgumentCount, signature.flags & 19 /* PropagatingFlags */); + /*resolvedTypePredicate*/ undefined, signature.minArgumentCount, signature.flags & 39 /* PropagatingFlags */); result.target = signature; result.mapper = mapper; return result; @@ -57103,7 +57869,7 @@ var ts; } return result; } - function getObjectTypeInstantiation(type, mapper) { + function getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) { var declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.symbol.declarations[0]; var links = getNodeLinks(declaration); var target = type.objectFlags & 4 /* Reference */ ? links.resolvedType : @@ -57131,17 +57897,19 @@ var ts; // instantiation cache key from the type IDs of the type arguments. var combinedMapper_1 = combineTypeMappers(type.mapper, mapper); var typeArguments = ts.map(typeParameters, function (t) { return getMappedType(t, combinedMapper_1); }); - var id = getTypeListId(typeArguments); + var newAliasSymbol = aliasSymbol || type.aliasSymbol; + var newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper); + var id = getTypeListId(typeArguments) + getAliasId(newAliasSymbol, newAliasTypeArguments); if (!target.instantiations) { target.instantiations = new ts.Map(); - target.instantiations.set(getTypeListId(typeParameters), target); + target.instantiations.set(getTypeListId(typeParameters) + getAliasId(target.aliasSymbol, target.aliasTypeArguments), target); } var result = target.instantiations.get(id); if (!result) { var newMapper = createTypeMapper(typeParameters, typeArguments); - result = target.objectFlags & 4 /* Reference */ ? createDeferredTypeReference(type.target, type.node, newMapper) : - target.objectFlags & 32 /* Mapped */ ? instantiateMappedType(target, newMapper) : - instantiateAnonymousType(target, newMapper); + result = target.objectFlags & 4 /* Reference */ ? createDeferredTypeReference(type.target, type.node, newMapper, newAliasSymbol, newAliasTypeArguments) : + target.objectFlags & 32 /* Mapped */ ? instantiateMappedType(target, newMapper, newAliasSymbol, newAliasTypeArguments) : + instantiateAnonymousType(target, newMapper, newAliasSymbol, newAliasTypeArguments); target.instantiations.set(id, result); } return result; @@ -57190,7 +57958,7 @@ var ts; } return undefined; } - function instantiateMappedType(type, mapper) { + function instantiateMappedType(type, mapper, aliasSymbol, aliasTypeArguments) { // For a homomorphic mapped type { [P in keyof T]: X }, where T is some type variable, the mapping // operation depends on T as follows: // * If T is a primitive type no mapping is performed and the result is simply T. @@ -57205,7 +57973,7 @@ var ts; if (typeVariable) { var mappedTypeVariable = instantiateType(typeVariable, mapper); if (typeVariable !== mappedTypeVariable) { - return mapType(getReducedType(mappedTypeVariable), function (t) { + return mapTypeWithAlias(getReducedType(mappedTypeVariable), function (t) { if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && t !== errorType) { if (!type.declaration.nameType) { if (isArrayType(t)) { @@ -57221,10 +57989,11 @@ var ts; return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper)); } return t; - }); + }, aliasSymbol, aliasTypeArguments); } } - return instantiateAnonymousType(type, mapper); + // If the constraint type of the instantiation is the wildcard type, return the wildcard type. + return instantiateType(getConstraintTypeFromMappedType(type), mapper) === wildcardType ? wildcardType : instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments); } function getModifiedReadonlyState(state, modifiers) { return modifiers & 1 /* IncludeReadonly */ ? true : modifiers & 2 /* ExcludeReadonly */ ? false : state; @@ -57271,7 +58040,7 @@ var ts; strictNullChecks && modifiers & 8 /* ExcludeOptional */ && isOptional ? getTypeWithFacts(propType, 524288 /* NEUndefined */) : propType; } - function instantiateAnonymousType(type, mapper) { + function instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments) { var result = createObjectType(type.objectFlags | 64 /* Instantiated */, type.symbol); if (type.objectFlags & 32 /* Mapped */) { result.declaration = type.declaration; @@ -57284,29 +58053,29 @@ var ts; } result.target = type; result.mapper = mapper; - result.aliasSymbol = type.aliasSymbol; - result.aliasTypeArguments = instantiateTypes(type.aliasTypeArguments, mapper); + result.aliasSymbol = aliasSymbol || type.aliasSymbol; + result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper); return result; } - function getConditionalTypeInstantiation(type, mapper) { + function getConditionalTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) { var root = type.root; if (root.outerTypeParameters) { // We are instantiating a conditional type that has one or more type parameters in scope. Apply the // mapper to the type parameters to produce the effective list of type arguments, and compute the // instantiation cache key from the type IDs of the type arguments. var typeArguments = ts.map(root.outerTypeParameters, function (t) { return getMappedType(t, mapper); }); - var id = getTypeListId(typeArguments); + var id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments); var result = root.instantiations.get(id); if (!result) { var newMapper = createTypeMapper(root.outerTypeParameters, typeArguments); - result = instantiateConditionalType(root, newMapper); + result = instantiateConditionalType(root, newMapper, aliasSymbol, aliasTypeArguments); root.instantiations.set(id, result); } return result; } return type; } - function instantiateConditionalType(root, mapper) { + function instantiateConditionalType(root, mapper, aliasSymbol, aliasTypeArguments) { // Check if we have a conditional type where the check type is a naked type parameter. If so, // the conditional type is distributive over union types and when T is instantiated to a union // type A | B, we produce (A extends U ? X : Y) | (B extends U ? X : Y). @@ -57314,31 +58083,34 @@ var ts; var checkType_1 = root.checkType; var instantiatedType = getMappedType(checkType_1, mapper); if (checkType_1 !== instantiatedType && instantiatedType.flags & (1048576 /* Union */ | 131072 /* Never */)) { - return mapType(instantiatedType, function (t) { return getConditionalType(root, prependTypeMapping(checkType_1, t, mapper)); }); + return mapTypeWithAlias(instantiatedType, function (t) { return getConditionalType(root, prependTypeMapping(checkType_1, t, mapper)); }, aliasSymbol, aliasTypeArguments); } } - return getConditionalType(root, mapper); + return getConditionalType(root, mapper, aliasSymbol, aliasTypeArguments); } function instantiateType(type, mapper) { - if (!(type && mapper && couldContainTypeVariables(type))) { + return type && mapper ? instantiateTypeWithAlias(type, mapper, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined) : type; + } + function instantiateTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) { + if (!couldContainTypeVariables(type)) { return type; } if (instantiationDepth === 50 || instantiationCount >= 5000000) { // We have reached 50 recursive type instantiations and there is a very high likelyhood we're dealing // with a combination of infinite generic types that perpetually generate new type identities. We stop // the recursion here by yielding the error type. - ts.tracing.instant("check" /* Check */, "instantiateType_DepthLimit", { typeId: type.id, instantiationDepth: instantiationDepth, instantiationCount: instantiationCount }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "instantiateType_DepthLimit", { typeId: type.id, instantiationDepth: instantiationDepth, instantiationCount: instantiationCount }); error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite); return errorType; } totalInstantiationCount++; instantiationCount++; instantiationDepth++; - var result = instantiateTypeWorker(type, mapper); + var result = instantiateTypeWorker(type, mapper, aliasSymbol, aliasTypeArguments); instantiationDepth--; return result; } - function instantiateTypeWorker(type, mapper) { + function instantiateTypeWorker(type, mapper, aliasSymbol, aliasTypeArguments) { var flags = type.flags; if (flags & 262144 /* TypeParameter */) { return getMappedType(type, mapper); @@ -57346,22 +58118,27 @@ var ts; if (flags & 524288 /* Object */) { var objectFlags = type.objectFlags; if (objectFlags & (4 /* Reference */ | 16 /* Anonymous */ | 32 /* Mapped */)) { - if (objectFlags & 4 /* Reference */ && !(type.node)) { + if (objectFlags & 4 /* Reference */ && !type.node) { var resolvedTypeArguments = type.resolvedTypeArguments; var newTypeArguments = instantiateTypes(resolvedTypeArguments, mapper); return newTypeArguments !== resolvedTypeArguments ? createNormalizedTypeReference(type.target, newTypeArguments) : type; } - return getObjectTypeInstantiation(type, mapper); + return getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments); } return type; } if (flags & 3145728 /* UnionOrIntersection */) { - var types = type.types; + var origin = type.flags & 1048576 /* Union */ ? type.origin : undefined; + var types = origin && origin.flags & 3145728 /* UnionOrIntersection */ ? origin.types : type.types; var newTypes = instantiateTypes(types, mapper); - return newTypes === types ? type : - flags & 2097152 /* Intersection */ ? - getIntersectionType(newTypes, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)) : - getUnionType(newTypes, 1 /* Literal */, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)); + if (newTypes === types && aliasSymbol === type.aliasSymbol) { + return type; + } + var newAliasSymbol = aliasSymbol || type.aliasSymbol; + var newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper); + return flags & 2097152 /* Intersection */ || origin && origin.flags & 2097152 /* Intersection */ ? + getIntersectionType(newTypes, newAliasSymbol, newAliasTypeArguments) : + getUnionType(newTypes, 1 /* Literal */, newAliasSymbol, newAliasTypeArguments); } if (flags & 4194304 /* Index */) { return getIndexType(instantiateType(type.type, mapper)); @@ -57373,10 +58150,12 @@ var ts; return getStringMappingType(type.symbol, instantiateType(type.type, mapper)); } if (flags & 8388608 /* IndexedAccess */) { - return getIndexedAccessType(instantiateType(type.objectType, mapper), instantiateType(type.indexType, mapper), type.noUncheckedIndexedAccessCandidate, /*accessNode*/ undefined, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)); + var newAliasSymbol = aliasSymbol || type.aliasSymbol; + var newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper); + return getIndexedAccessType(instantiateType(type.objectType, mapper), instantiateType(type.indexType, mapper), type.noUncheckedIndexedAccessCandidate, /*accessNode*/ undefined, newAliasSymbol, newAliasTypeArguments); } if (flags & 16777216 /* Conditional */) { - return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper)); + return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper), aliasSymbol, aliasTypeArguments); } if (flags & 33554432 /* Substitution */) { var maybeVariable = instantiateType(type.baseType, mapper); @@ -58356,7 +59135,7 @@ var ts; reportIncompatibleStack(); } if (overflow) { - ts.tracing.instant("check" /* Check */, "checkTypeRelatedTo_DepthLimit", { sourceId: source.id, targetId: target.id, depth: depth }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "checkTypeRelatedTo_DepthLimit", { sourceId: source.id, targetId: target.id, depth: depth }); var diag = error(errorNode || currentNode, ts.Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target)); if (errorOutputContainer) { (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag); @@ -58385,7 +59164,7 @@ var ts; } var diag = ts.createDiagnosticForNodeFromMessageChain(errorNode, errorInfo, relatedInformation); if (relatedInfo) { - ts.addRelatedInfo.apply(void 0, __spreadArrays([diag], relatedInfo)); + ts.addRelatedInfo.apply(void 0, __spreadArray([diag], relatedInfo)); } if (errorOutputContainer) { (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag); @@ -58428,7 +59207,7 @@ var ts; reportError.apply(void 0, stack[0]); if (info) { // Actually do the last relation error - reportRelationError.apply(void 0, __spreadArrays([/*headMessage*/ undefined], info)); + reportRelationError.apply(void 0, __spreadArray([/*headMessage*/ undefined], info)); } return; } @@ -58508,13 +59287,13 @@ var ts; for (var _i = 0, secondaryRootErrors_1 = secondaryRootErrors; _i < secondaryRootErrors_1.length; _i++) { var _b = secondaryRootErrors_1[_i], msg = _b[0], args = _b.slice(1); var originalValue = msg.elidedInCompatabilityPyramid; - msg.elidedInCompatabilityPyramid = false; // Teporarily override elision to ensure error is reported - reportError.apply(void 0, __spreadArrays([msg], args)); + msg.elidedInCompatabilityPyramid = false; // Temporarily override elision to ensure error is reported + reportError.apply(void 0, __spreadArray([msg], args)); msg.elidedInCompatabilityPyramid = originalValue; } if (info) { // Actually do the last relation error - reportRelationError.apply(void 0, __spreadArrays([/*headMessage*/ undefined], info)); + reportRelationError.apply(void 0, __spreadArray([/*headMessage*/ undefined], info)); } } function reportError(message, arg0, arg1, arg2, arg3) { @@ -58675,7 +59454,7 @@ var ts; if (isPerformingExcessPropertyChecks) { if (hasExcessProperties(source, target, reportErrors)) { if (reportErrors) { - reportRelationError(headMessage, source, target); + reportRelationError(headMessage, source, originalTarget.aliasSymbol ? originalTarget : target); } return 0 /* False */; } @@ -58686,55 +59465,34 @@ var ts; (getPropertiesOfType(source).length > 0 || typeHasCallOrConstructSignatures(source)); if (isPerformingCommonPropertyChecks && !hasCommonProperties(source, target, isComparingJsxAttributes)) { if (reportErrors) { + var sourceString = typeToString(originalSource.aliasSymbol ? originalSource : source); + var targetString = typeToString(originalTarget.aliasSymbol ? originalTarget : target); var calls = getSignaturesOfType(source, 0 /* Call */); var constructs = getSignaturesOfType(source, 1 /* Construct */); if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, /*reportErrors*/ false) || constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, /*reportErrors*/ false)) { - reportError(ts.Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, typeToString(source), typeToString(target)); + reportError(ts.Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, sourceString, targetString); } else { - reportError(ts.Diagnostics.Type_0_has_no_properties_in_common_with_type_1, typeToString(source), typeToString(target)); + reportError(ts.Diagnostics.Type_0_has_no_properties_in_common_with_type_1, sourceString, targetString); } } return 0 /* False */; } + traceUnionsOrIntersectionsTooLarge(source, target); var result = 0 /* False */; var saveErrorInfo = captureErrorCalculationState(); // Note that these checks are specifically ordered to produce correct results. In particular, // we need to deconstruct unions before intersections (because unions are always at the top), // and we need to handle "each" relations before "some" relations for the same kind of type. - if (source.flags & 1048576 /* Union */) { - result = relation === comparableRelation ? - someTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* Primitive */), intersectionState) : - eachTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* Primitive */), intersectionState); + if (source.flags & 3145728 /* UnionOrIntersection */ || target.flags & 3145728 /* UnionOrIntersection */) { + result = getConstituentCount(source) * getConstituentCount(target) >= 4 ? + recursiveTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */) : + structuredTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */); } - else { - if (target.flags & 1048576 /* Union */) { - result = typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source), target, reportErrors && !(source.flags & 131068 /* Primitive */) && !(target.flags & 131068 /* Primitive */)); - } - else if (target.flags & 2097152 /* Intersection */) { - result = typeRelatedToEachType(getRegularTypeOfObjectLiteral(source), target, reportErrors, 2 /* Target */); - } - else if (source.flags & 2097152 /* Intersection */) { - // Check to see if any constituents of the intersection are immediately related to the target. - // - // Don't report errors though. Checking whether a constituent is related to the source is not actually - // useful and leads to some confusing error messages. Instead it is better to let the below checks - // take care of this, or to not elaborate at all. For instance, - // - // - For an object type (such as 'C = A & B'), users are usually more interested in structural errors. - // - // - For a union type (such as '(A | B) = (C & D)'), it's better to hold onto the whole intersection - // than to report that 'D' is not assignable to 'A' or 'B'. - // - // - For a primitive type or type parameter (such as 'number = A & B') there is no point in - // breaking the intersection apart. - result = someTypeRelatedToType(source, target, /*reportErrors*/ false, 1 /* Source */); - } - if (!result && (source.flags & 469499904 /* StructuredOrInstantiable */ || target.flags & 469499904 /* StructuredOrInstantiable */)) { - if (result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState)) { - resetErrorInfo(saveErrorInfo); - } + if (!result && !(source.flags & 1048576 /* Union */) && (source.flags & (469499904 /* StructuredOrInstantiable */) || target.flags & 469499904 /* StructuredOrInstantiable */)) { + if (result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState)) { + resetErrorInfo(saveErrorInfo); } } if (!result && source.flags & (2097152 /* Intersection */ | 262144 /* TypeParameter */)) { @@ -58827,11 +59585,37 @@ var ts; } } } + function traceUnionsOrIntersectionsTooLarge(source, target) { + if (!ts.tracing) { + return; + } + if ((source.flags & 3145728 /* UnionOrIntersection */) && (target.flags & 3145728 /* UnionOrIntersection */)) { + var sourceUnionOrIntersection = source; + var targetUnionOrIntersection = target; + if (sourceUnionOrIntersection.objectFlags & targetUnionOrIntersection.objectFlags & 262144 /* PrimitiveUnion */) { + // There's a fast path for comparing primitive unions + return; + } + var sourceSize = sourceUnionOrIntersection.types.length; + var targetSize = targetUnionOrIntersection.types.length; + if (sourceSize * targetSize > 1E6) { + ts.tracing.instant("checkTypes" /* CheckTypes */, "traceUnionsOrIntersectionsTooLarge_DepthLimit", { + sourceId: source.id, + sourceSize: sourceSize, + targetId: target.id, + targetSize: targetSize, + pos: errorNode === null || errorNode === void 0 ? void 0 : errorNode.pos, + end: errorNode === null || errorNode === void 0 ? void 0 : errorNode.end + }); + } + } + } function isIdenticalTo(source, target) { var flags = source.flags & target.flags; if (!(flags & 469237760 /* Substructure */)) { return 0 /* False */; } + traceUnionsOrIntersectionsTooLarge(source, target); if (flags & 3145728 /* UnionOrIntersection */) { var result_6 = eachTypeRelatedToSomeType(source, target); if (result_6) { @@ -58995,14 +59779,30 @@ var ts; } return 0 /* False */; } + function getUndefinedStrippedTargetIfNeeded(source, target) { + // As a builtin type, `undefined` is a very low type ID - making it almsot always first, making this a very fast check to see + // if we need to strip `undefined` from the target + if (source.flags & 1048576 /* Union */ && target.flags & 1048576 /* Union */ && + !(source.types[0].flags & 32768 /* Undefined */) && target.types[0].flags & 32768 /* Undefined */) { + return extractTypesOfKind(target, ~32768 /* Undefined */); + } + return target; + } function eachTypeRelatedToType(source, target, reportErrors, intersectionState) { var result = -1 /* True */; var sourceTypes = source.types; + // We strip `undefined` from the target if the `source` trivially doesn't contain it for our correspondence-checking fastpath + // since `undefined` is frequently added by optionality and would otherwise spoil a potentially useful correspondence + var undefinedStrippedTarget = getUndefinedStrippedTargetIfNeeded(source, target); for (var i = 0; i < sourceTypes.length; i++) { var sourceType = sourceTypes[i]; - if (target.flags & 1048576 /* Union */ && target.types.length === sourceTypes.length) { + if (undefinedStrippedTarget.flags & 1048576 /* Union */ && sourceTypes.length >= undefinedStrippedTarget.types.length && sourceTypes.length % undefinedStrippedTarget.types.length === 0) { // many unions are mappings of one another; in such cases, simply comparing members at the same index can shortcut the comparison - var related_1 = isRelatedTo(sourceType, target.types[i], /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState); + // such unions will have identical lengths, and their corresponding elements will match up. Another common scenario is where a large + // union has a union of objects intersected with it. In such cases, if the input was, eg `("a" | "b" | "c") & (string | boolean | {} | {whatever})`, + // the result will have the structure `"a" | "b" | "c" | "a" & {} | "b" & {} | "c" & {} | "a" & {whatever} | "b" & {whatever} | "c" & {whatever}` + // - the resulting union has a length which is a multiple of the original union, and the elements correspond modulo the length of the original union + var related_1 = isRelatedTo(sourceType, undefinedStrippedTarget.types[i % undefinedStrippedTarget.types.length], /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState); if (related_1) { result &= related_1; continue; @@ -59084,7 +59884,7 @@ var ts; if (overflow) { return 0 /* False */; } - var id = getRelationKey(source, target, intersectionState | (inPropertyCheck ? 8 /* InPropertyCheck */ : 0), relation); + var id = getRelationKey(source, target, intersectionState | (inPropertyCheck ? 16 /* InPropertyCheck */ : 0), relation); var entry = relation.get(id); if (entry !== undefined) { if (reportErrors && entry & 2 /* Failed */ && !(entry & 4 /* Reported */)) { @@ -59143,7 +59943,7 @@ var ts; }; } if (expandingFlags === 3 /* Both */) { - ts.tracing.instant("check" /* Check */, "recursiveTypeRelatedTo_DepthLimit", { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "recursiveTypeRelatedTo_DepthLimit", { sourceId: source.id, sourceIdStack: sourceStack.map(function (t) { return t.id; }), targetId: target.id, @@ -59178,15 +59978,46 @@ var ts; return result; } function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) { - ts.tracing.push("check" /* Check */, "structuredTypeRelatedTo", { sourceId: source.id, targetId: target.id }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* CheckTypes */, "structuredTypeRelatedTo", { sourceId: source.id, targetId: target.id }); var result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState); - ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); return result; } function structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState) { if (intersectionState & 4 /* PropertyCheck */) { return propertiesRelatedTo(source, target, reportErrors, /*excludedProperties*/ undefined, 0 /* None */); } + if (intersectionState & 8 /* UnionIntersectionCheck */) { + // Note that these checks are specifically ordered to produce correct results. In particular, + // we need to deconstruct unions before intersections (because unions are always at the top), + // and we need to handle "each" relations before "some" relations for the same kind of type. + if (source.flags & 1048576 /* Union */) { + return relation === comparableRelation ? + someTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* Primitive */), intersectionState & ~8 /* UnionIntersectionCheck */) : + eachTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* Primitive */), intersectionState & ~8 /* UnionIntersectionCheck */); + } + if (target.flags & 1048576 /* Union */) { + return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source), target, reportErrors && !(source.flags & 131068 /* Primitive */) && !(target.flags & 131068 /* Primitive */)); + } + if (target.flags & 2097152 /* Intersection */) { + return typeRelatedToEachType(getRegularTypeOfObjectLiteral(source), target, reportErrors, 2 /* Target */); + } + // Source is an intersection. Check to see if any constituents of the intersection are immediately related + // to the target. + // + // Don't report errors though. Checking whether a constituent is related to the source is not actually + // useful and leads to some confusing error messages. Instead it is better to let the below checks + // take care of this, or to not elaborate at all. For instance, + // + // - For an object type (such as 'C = A & B'), users are usually more interested in structural errors. + // + // - For a union type (such as '(A | B) = (C & D)'), it's better to hold onto the whole intersection + // than to report that 'D' is not assignable to 'A' or 'B'. + // + // - For a primitive type or type parameter (such as 'number = A & B') there is no point in + // breaking the intersection apart. + return someTypeRelatedToType(source, target, /*reportErrors*/ false, 1 /* Source */); + } var flags = source.flags & target.flags; if (relation === identityRelation && !(flags & 524288 /* Object */)) { if (flags & 4194304 /* Index */) { @@ -59661,7 +60492,7 @@ var ts; numCombinations *= countTypes(getTypeOfSymbol(sourceProperty)); if (numCombinations > 25) { // We've reached the complexity limit. - ts.tracing.instant("check" /* Check */, "typeRelatedToDiscriminatedType_DepthLimit", { sourceId: source.id, targetId: target.id, numCombinations: numCombinations }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "typeRelatedToDiscriminatedType_DepthLimit", { sourceId: source.id, targetId: target.id, numCombinations: numCombinations }); return 0 /* False */; } } @@ -59682,8 +60513,8 @@ var ts; var matchingTypes = []; var _loop_17 = function (combination) { var hasMatch = false; - outer: for (var _i = 0, _a = target.types; _i < _a.length; _i++) { - var type = _a[_i]; + outer: for (var _c = 0, _d = target.types; _c < _d.length; _c++) { + var type = _d[_c]; var _loop_18 = function (i) { var sourceProperty = sourcePropertiesFiltered[i]; var targetProperty = getPropertyOfType(type, sourceProperty.escapedName); @@ -59882,7 +60713,7 @@ var ts; } if (props.length === 1) { var propName = symbolToString(unmatchedProperty); - reportError.apply(void 0, __spreadArrays([ts.Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2, propName], getTypeNamesForErrorDisplay(source, target))); + reportError.apply(void 0, __spreadArray([ts.Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2, propName], getTypeNamesForErrorDisplay(source, target))); if (ts.length(unmatchedProperty.declarations)) { associateRelatedInfo(ts.createDiagnosticForNode(unmatchedProperty.declarations[0], ts.Diagnostics._0_is_declared_here, propName)); } @@ -59942,48 +60773,60 @@ var ts; } return 0 /* False */; } - var maxArity = Math.max(sourceArity, targetArity); - for (var i = 0; i < maxArity; i++) { - var targetFlags = i < targetArity ? target.target.elementFlags[i] : targetRestFlag; - var sourceFlags = isTupleType(source) && i < sourceArity ? source.target.elementFlags[i] : sourceRestFlag; - var canExcludeDiscriminants = !!excludedProperties; - if (sourceFlags && targetFlags) { - if (targetFlags & 8 /* Variadic */ && !(sourceFlags & 8 /* Variadic */) || - (sourceFlags & 8 /* Variadic */ && !(targetFlags & 12 /* Variable */))) { - if (reportErrors) { - reportError(ts.Diagnostics.Element_at_index_0_is_variadic_in_one_type_but_not_in_the_other, i); - } - return 0 /* False */; + var sourceTypeArguments = getTypeArguments(source); + var targetTypeArguments = getTypeArguments(target); + var startCount = Math.min(isTupleType(source) ? getStartElementCount(source.target, 11 /* NonRest */) : 0, getStartElementCount(target.target, 11 /* NonRest */)); + var endCount = Math.min(isTupleType(source) ? getEndElementCount(source.target, 11 /* NonRest */) : 0, targetRestFlag ? getEndElementCount(target.target, 11 /* NonRest */) : 0); + var canExcludeDiscriminants = !!excludedProperties; + for (var i = 0; i < targetArity; i++) { + var sourceIndex = i < targetArity - endCount ? i : i + sourceArity - targetArity; + var sourceFlags = isTupleType(source) && (i < startCount || i >= targetArity - endCount) ? source.target.elementFlags[sourceIndex] : 4 /* Rest */; + var targetFlags = target.target.elementFlags[i]; + if (targetFlags & 8 /* Variadic */ && !(sourceFlags & 8 /* Variadic */)) { + if (reportErrors) { + reportError(ts.Diagnostics.Source_provides_no_match_for_variadic_element_at_position_0_in_target, i); } - if (targetFlags & 1 /* Required */) { - if (!(sourceFlags & 1 /* Required */)) { - if (reportErrors) { - reportError(ts.Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2, i, typeToString(source), typeToString(target)); - } - return 0 /* False */; - } + return 0 /* False */; + } + if (sourceFlags & 8 /* Variadic */ && !(targetFlags & 12 /* Variable */)) { + if (reportErrors) { + reportError(ts.Diagnostics.Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target, sourceIndex, i); } - // We can only exclude discriminant properties if we have not yet encountered a variable-length element. - if (canExcludeDiscriminants) { - if (sourceFlags & 12 /* Variable */ || targetFlags & 12 /* Variable */) { - canExcludeDiscriminants = false; - } - if (canExcludeDiscriminants && (excludedProperties === null || excludedProperties === void 0 ? void 0 : excludedProperties.has(("" + i)))) { - continue; - } + return 0 /* False */; + } + if (targetFlags & 1 /* Required */ && !(sourceFlags & 1 /* Required */)) { + if (reportErrors) { + reportError(ts.Diagnostics.Source_provides_no_match_for_required_element_at_position_0_in_target, i); } - var sourceType = getTypeArguments(source)[Math.min(i, sourceArity - 1)]; - var targetType = getTypeArguments(target)[Math.min(i, targetArity - 1)]; - var targetCheckType = sourceFlags & 8 /* Variadic */ && targetFlags & 4 /* Rest */ ? createArrayType(targetType) : targetType; - var related = isRelatedTo(sourceType, targetCheckType, reportErrors, /*headMessage*/ undefined, intersectionState); - if (!related) { - if (reportErrors) { - reportIncompatibleError(ts.Diagnostics.Types_of_property_0_are_incompatible, i); + return 0 /* False */; + } + // We can only exclude discriminant properties if we have not yet encountered a variable-length element. + if (canExcludeDiscriminants) { + if (sourceFlags & 12 /* Variable */ || targetFlags & 12 /* Variable */) { + canExcludeDiscriminants = false; + } + if (canExcludeDiscriminants && (excludedProperties === null || excludedProperties === void 0 ? void 0 : excludedProperties.has(("" + i)))) { + continue; + } + } + var sourceType = !isTupleType(source) ? sourceTypeArguments[0] : + i < startCount || i >= targetArity - endCount ? sourceTypeArguments[sourceIndex] : + getElementTypeOfSliceOfTupleType(source, startCount, endCount) || neverType; + var targetType = targetTypeArguments[i]; + var targetCheckType = sourceFlags & 8 /* Variadic */ && targetFlags & 4 /* Rest */ ? createArrayType(targetType) : targetType; + var related = isRelatedTo(sourceType, targetCheckType, reportErrors, /*headMessage*/ undefined, intersectionState); + if (!related) { + if (reportErrors) { + if (i < startCount || i >= targetArity - endCount || sourceArity - startCount - endCount === 1) { + reportIncompatibleError(ts.Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, sourceIndex, i); + } + else { + reportIncompatibleError(ts.Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target, startCount, sourceArity - endCount - 1, i); } - return 0 /* False */; } - result &= related; + return 0 /* False */; } + result &= related; } return result; } @@ -60072,7 +60915,9 @@ var ts; var targetSignatures = getSignaturesOfType(target, (targetIsJSConstructor && kind === 1 /* Construct */) ? 0 /* Call */ : kind); if (kind === 1 /* Construct */ && sourceSignatures.length && targetSignatures.length) { - if (ts.isAbstractConstructorType(source) && !ts.isAbstractConstructorType(target)) { + var sourceIsAbstract = !!(sourceSignatures[0].flags & 4 /* Abstract */); + var targetIsAbstract = !!(targetSignatures[0].flags & 4 /* Abstract */); + if (sourceIsAbstract && !targetIsAbstract) { // An abstract constructor type is not assignable to a non-abstract constructor type // as it would otherwise be possible to new an abstract class. Note that the assignability // check we perform for an extends clause excludes construct signatures from the target, @@ -60195,7 +61040,11 @@ var ts; continue; } if (kind === 0 /* String */ || isNumericLiteralName(prop.escapedName)) { - var related = isRelatedTo(getTypeOfSymbol(prop), target, reportErrors); + var propType = getTypeOfSymbol(prop); + var type = propType.flags & 32768 /* Undefined */ || !(kind === 0 /* String */ && prop.flags & 16777216 /* Optional */) + ? propType + : getTypeWithFacts(propType, 524288 /* NEUndefined */); + var related = isRelatedTo(type, target, reportErrors); if (!related) { if (reportErrors) { reportError(ts.Diagnostics.Property_0_is_incompatible_with_index_signature, symbolToString(prop)); @@ -60398,7 +61247,7 @@ var ts; if (typeParameters === void 0) { typeParameters = ts.emptyArray; } var variances = cache.variances; if (!variances) { - ts.tracing.push("check" /* Check */, "getVariancesWorker", { arity: typeParameters.length, id: (_c = (_a = cache.id) !== null && _a !== void 0 ? _a : (_b = cache.declaredType) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : -1 }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* CheckTypes */, "getVariancesWorker", { arity: typeParameters.length, id: (_c = (_a = cache.id) !== null && _a !== void 0 ? _a : (_b = cache.declaredType) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : -1 }); // The emptyArray singleton is used to signal a recursive invocation. cache.variances = ts.emptyArray; variances = []; @@ -60437,7 +61286,7 @@ var ts; _loop_19(tp); } cache.variances = variances; - ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); } return variances; } @@ -60738,8 +61587,8 @@ var ts; } function literalTypesWithSameBaseType(types) { var commonBaseType; - for (var _i = 0, types_13 = types; _i < types_13.length; _i++) { - var t = types_13[_i]; + for (var _i = 0, types_14 = types; _i < types_14.length; _i++) { + var t = types_14[_i]; var baseType = getBaseTypeOfLiteralType(t); if (!commonBaseType) { commonBaseType = baseType; @@ -60825,7 +61674,7 @@ var ts; type.flags & 256 /* NumberLiteral */ ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 512 /* BooleanLiteral */ ? booleanType : - type.flags & 1048576 /* Union */ ? getUnionType(ts.sameMap(type.types, getBaseTypeOfLiteralType)) : + type.flags & 1048576 /* Union */ ? mapType(type, getBaseTypeOfLiteralType) : type; } function getWidenedLiteralType(type) { @@ -60834,12 +61683,12 @@ var ts; type.flags & 256 /* NumberLiteral */ && isFreshLiteralType(type) ? numberType : type.flags & 2048 /* BigIntLiteral */ && isFreshLiteralType(type) ? bigintType : type.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(type) ? booleanType : - type.flags & 1048576 /* Union */ ? getUnionType(ts.sameMap(type.types, getWidenedLiteralType)) : + type.flags & 1048576 /* Union */ ? mapType(type, getWidenedLiteralType) : type; } function getWidenedUniqueESSymbolType(type) { return type.flags & 8192 /* UniqueESSymbol */ ? esSymbolType : - type.flags & 1048576 /* Union */ ? getUnionType(ts.sameMap(type.types, getWidenedUniqueESSymbolType)) : + type.flags & 1048576 /* Union */ ? mapType(type, getWidenedUniqueESSymbolType) : type; } function getWidenedLiteralLikeTypeForContextualType(type, contextualType) { @@ -60885,9 +61734,6 @@ var ts; var restType = getRestTypeOfTupleType(type); return restType && createArrayType(restType); } - function getEndLengthOfType(type) { - return isTupleType(type) ? getTypeReferenceArity(type) - ts.findLastIndex(type.target.elementFlags, function (f) { return !(f & (1 /* Required */ | 2 /* Optional */)); }) - 1 : 0; - } function getElementTypeOfSliceOfTupleType(type, index, endSkipCount, writing) { if (endSkipCount === void 0) { endSkipCount = 0; } if (writing === void 0) { writing = false; } @@ -60913,8 +61759,8 @@ var ts; } function getFalsyFlagsOfTypes(types) { var result = 0; - for (var _i = 0, types_14 = types; _i < types_14.length; _i++) { - var t = types_14[_i]; + for (var _i = 0, types_15 = types; _i < types_15.length; _i++) { + var t = types_15[_i]; result |= getFalsyFlags(t); } return result; @@ -61586,7 +62432,7 @@ var ts; // Two object types that each have a property that is unmatched in the other are definitely unrelated. return isTupleType(source) && isTupleType(target) ? tupleTypesDefinitelyUnrelated(source, target) : !!getUnmatchedProperty(source, target, /*requireOptionalProperties*/ false, /*matchDiscriminantProperties*/ true) && - !!getUnmatchedProperty(target, source, /*requireOptionalProperties*/ false, /*matchDiscriminantProperties*/ true); + !!getUnmatchedProperty(target, source, /*requireOptionalProperties*/ false, /*matchDiscriminantProperties*/ false); } function getTypeFromInference(inference) { return inference.candidates ? getUnionType(inference.candidates, 2 /* Subtype */) : @@ -61868,12 +62714,6 @@ var ts; invokeOnce(source, target, inferFromObjectTypes); } } - if (source.flags & 25165824 /* Simplifiable */) { - var simplified = getSimplifiedType(source, contravariant); - if (simplified !== source) { - inferFromTypes(simplified, target); - } - } } function inferWithPriority(source, target, newPriority) { var savePriority = priority; @@ -61971,8 +62811,8 @@ var ts; } function getSingleTypeVariableFromIntersectionTypes(types) { var typeVariable; - for (var _i = 0, types_15 = types; _i < types_15.length; _i++) { - var type = types_15[_i]; + for (var _i = 0, types_16 = types; _i < types_16.length; _i++) { + var type = types_16[_i]; var t = type.flags & 2097152 /* Intersection */ && ts.find(type.types, function (t) { return !!getInferenceInfoForType(t); }); if (!t || typeVariable && t !== typeVariable) { return undefined; @@ -62173,20 +63013,16 @@ var ts; return; } var startLength = isTupleType(source) ? Math.min(source.target.fixedLength, target.target.fixedLength) : 0; - var sourceRestType = !isTupleType(source) || sourceArity > 0 && source.target.elementFlags[sourceArity - 1] & 4 /* Rest */ ? - getTypeArguments(source)[sourceArity - 1] : undefined; - var endLength = !(target.target.combinedFlags & 12 /* Variable */) ? 0 : - sourceRestType ? getEndLengthOfType(target) : - Math.min(getEndLengthOfType(source), getEndLengthOfType(target)); - var sourceEndLength = sourceRestType ? 0 : endLength; + var endLength = Math.min(isTupleType(source) ? getEndElementCount(source.target, 3 /* Fixed */) : 0, target.target.hasRestElement ? getEndElementCount(target.target, 3 /* Fixed */) : 0); // Infer between starting fixed elements. for (var i = 0; i < startLength; i++) { inferFromTypes(getTypeArguments(source)[i], elementTypes[i]); } - if (sourceRestType && sourceArity - startLength === 1) { + if (!isTupleType(source) || sourceArity - startLength - endLength === 1 && source.target.elementFlags[startLength] & 4 /* Rest */) { // Single rest element remains in source, infer from that to every element in target + var restType = getTypeArguments(source)[startLength]; for (var i = startLength; i < targetArity - endLength; i++) { - inferFromTypes(elementFlags[i] & 8 /* Variadic */ ? createArrayType(sourceRestType) : sourceRestType, elementTypes[i]); + inferFromTypes(elementFlags[i] & 8 /* Variadic */ ? createArrayType(restType) : restType, elementTypes[i]); } } else { @@ -62196,20 +63032,20 @@ var ts; var targetInfo = getInferenceInfoForType(elementTypes[startLength]); if (targetInfo && targetInfo.impliedArity !== undefined) { // Infer slices from source based on implied arity of T. - inferFromTypes(sliceTupleType(source, startLength, sourceEndLength + sourceArity - targetInfo.impliedArity), elementTypes[startLength]); - inferFromTypes(sliceTupleType(source, startLength + targetInfo.impliedArity, sourceEndLength), elementTypes[startLength + 1]); + inferFromTypes(sliceTupleType(source, startLength, endLength + sourceArity - targetInfo.impliedArity), elementTypes[startLength]); + inferFromTypes(sliceTupleType(source, startLength + targetInfo.impliedArity, endLength), elementTypes[startLength + 1]); } } else if (middleLength === 1 && elementFlags[startLength] & 8 /* Variadic */) { // Middle of target is exactly one variadic element. Infer the slice between the fixed parts in the source. // If target ends in optional element(s), make a lower priority a speculative inference. var endsInOptional = target.target.elementFlags[targetArity - 1] & 2 /* Optional */; - var sourceSlice = isTupleType(source) ? sliceTupleType(source, startLength, sourceEndLength) : createArrayType(sourceRestType); + var sourceSlice = isTupleType(source) ? sliceTupleType(source, startLength, endLength) : createArrayType(getTypeArguments(source)[0]); inferWithPriority(sourceSlice, elementTypes[startLength], endsInOptional ? 2 /* SpeculativeTuple */ : 0); } else if (middleLength === 1 && elementFlags[startLength] & 4 /* Rest */) { // Middle of target is exactly one rest element. If middle of source is not empty, infer union of middle element types. - var restType = isTupleType(source) ? getElementTypeOfSliceOfTupleType(source, startLength, sourceEndLength) : sourceRestType; + var restType = isTupleType(source) ? getElementTypeOfSliceOfTupleType(source, startLength, endLength) : getTypeArguments(source)[0]; if (restType) { inferFromTypes(restType, elementTypes[startLength]); } @@ -62217,7 +63053,7 @@ var ts; } // Infer between ending fixed elements for (var i = 0; i < endLength; i++) { - inferFromTypes(sourceRestType || getTypeArguments(source)[sourceArity - i - 1], elementTypes[targetArity - i - 1]); + inferFromTypes(getTypeArguments(source)[sourceArity - i - 1], elementTypes[targetArity - i - 1]); } return; } @@ -62514,6 +63350,12 @@ var ts; return ts.isAccessExpression(target) && getAccessedPropertyName(source) === getAccessedPropertyName(target) && isMatchingReference(source.expression, target.expression); + case 157 /* QualifiedName */: + return ts.isAccessExpression(target) && + source.right.escapedText === getAccessedPropertyName(target) && + isMatchingReference(source.left, target.expression); + case 216 /* BinaryExpression */: + return (ts.isBinaryExpression(source) && source.operatorToken.kind === 27 /* CommaToken */ && isMatchingReference(source.right, target)); } return false; } @@ -62577,17 +63419,17 @@ var ts; function isOrContainsMatchingReference(source, target) { return isMatchingReference(source, target) || containsMatchingReference(source, target); } - function hasMatchingArgument(callExpression, reference) { - if (callExpression.arguments) { - for (var _i = 0, _a = callExpression.arguments; _i < _a.length; _i++) { + function hasMatchingArgument(expression, reference) { + if (expression.arguments) { + for (var _i = 0, _a = expression.arguments; _i < _a.length; _i++) { var argument = _a[_i]; if (isOrContainsMatchingReference(reference, argument)) { return true; } } } - if (callExpression.expression.kind === 201 /* PropertyAccessExpression */ && - isOrContainsMatchingReference(reference, callExpression.expression.expression)) { + if (expression.expression.kind === 201 /* PropertyAccessExpression */ && + isOrContainsMatchingReference(reference, expression.expression.expression)) { return true; } return false; @@ -62635,8 +63477,8 @@ var ts; } function getTypeFactsOfTypes(types) { var result = 0 /* None */; - for (var _i = 0, types_16 = types; _i < types_16.length; _i++) { - var t = types_16[_i]; + for (var _i = 0, types_17 = types; _i < types_17.length; _i++) { + var t = types_17[_i]; result |= getTypeFacts(t); } return result; @@ -62708,7 +63550,8 @@ var ts; return 0 /* None */; } if (flags & 465829888 /* Instantiable */) { - return getTypeFacts(getBaseConstraintOfType(type) || unknownType); + return !isPatternLiteralType(type) ? getTypeFacts(getBaseConstraintOfType(type) || unknownType) : + strictNullChecks ? 7929345 /* NonEmptyStringStrictFacts */ : 16776705 /* NonEmptyStringFacts */; } if (flags & 3145728 /* UnionOrIntersection */) { return getTypeFactsOfTypes(type.types); @@ -62923,7 +63766,27 @@ var ts; if (type.flags & 1048576 /* Union */) { var types = type.types; var filtered = ts.filter(types, f); - return filtered === types ? type : getUnionTypeFromSortedList(filtered, type.objectFlags); + if (filtered === types) { + return type; + } + var origin = type.origin; + var newOrigin = void 0; + if (origin && origin.flags & 1048576 /* Union */) { + // If the origin type is a (denormalized) union type, filter its non-union constituents. If that ends + // up removing a smaller number of types than in the normalized constituent set (meaning some of the + // filtered types are within nested unions in the origin), then we can't construct a new origin type. + // Otherwise, if we have exactly one type left in the origin set, return that as the filtered type. + // Otherwise, construct a new filtered origin type. + var originTypes = origin.types; + var originFiltered = ts.filter(originTypes, function (t) { return !!(t.flags & 1048576 /* Union */) || f(t); }); + if (originTypes.length - originFiltered.length === types.length - filtered.length) { + if (originFiltered.length === 1) { + return originFiltered[0]; + } + newOrigin = createOriginUnionOrIntersectionType(1048576 /* Union */, originFiltered); + } + } + return getUnionTypeFromSortedList(filtered, type.objectFlags, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, newOrigin); } return type.flags & 131072 /* Never */ || f(type) ? type : neverType; } @@ -62937,10 +63800,14 @@ var ts; if (!(type.flags & 1048576 /* Union */)) { return mapper(type); } + var origin = type.origin; + var types = origin && origin.flags & 1048576 /* Union */ ? origin.types : type.types; var mappedTypes; - for (var _i = 0, _a = type.types; _i < _a.length; _i++) { - var t = _a[_i]; - var mapped = mapper(t); + var changed = false; + for (var _i = 0, types_18 = types; _i < types_18.length; _i++) { + var t = types_18[_i]; + var mapped = t.flags & 1048576 /* Union */ ? mapType(t, mapper, noReductions) : mapper(t); + changed || (changed = t !== mapped); if (mapped) { if (!mappedTypes) { mappedTypes = [mapped]; @@ -62950,7 +63817,15 @@ var ts; } } } - return mappedTypes && getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */); + return changed ? mappedTypes && getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */) : type; + } + function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) { + return type.flags & 1048576 /* Union */ && aliasSymbol ? + getUnionType(ts.map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) : + mapType(type, mapper); + } + function getConstituentCount(type) { + return type.flags & 3145728 /* UnionOrIntersection */ ? type.types.length : 1; } function extractTypesOfKind(type, kind) { return filterType(type, function (t) { return (t.flags & kind) !== 0; }); @@ -63017,8 +63892,8 @@ var ts; } function isEvolvingArrayTypeList(types) { var hasEvolvingArrayType = false; - for (var _i = 0, types_17 = types; _i < types_17.length; _i++) { - var t = types_17[_i]; + for (var _i = 0, types_19 = types; _i < types_19.length; _i++) { + var t = types_19[_i]; if (!(t.flags & 131072 /* Never */)) { if (!(ts.getObjectFlags(t) & 256 /* EvolvingArray */)) { return false; @@ -63028,14 +63903,6 @@ var ts; } return hasEvolvingArrayType; } - // At flow control branch or loop junctions, if the type along every antecedent code path - // is an evolving array type, we construct a combined evolving array type. Otherwise we - // finalize all evolving array types. - function getUnionOrEvolvingArrayType(types, subtypeReduction) { - return isEvolvingArrayTypeList(types) ? - getEvolvingArrayType(getUnionType(ts.map(types, getElementTypeOfEvolvingArrayType))) : - getUnionType(ts.sameMap(types, finalizeEvolvingArrayType), subtypeReduction); - } // Return true if the given node is 'x' in an 'x.length', x.push(value)', 'x.unshift(value)' or // 'x[n] = value' operation, where 'n' is an expression of type any, undefined, or a number-like type. function isEvolvingArrayOperationTarget(node) { @@ -63103,10 +63970,24 @@ var ts; return getExplicitThisType(node); case 105 /* SuperKeyword */: return checkSuperExpression(node); - case 201 /* PropertyAccessExpression */: + case 201 /* PropertyAccessExpression */: { var type = getTypeOfDottedName(node.expression, diagnostic); - var prop = type && getPropertyOfType(type, node.name.escapedText); - return prop && getExplicitTypeOfSymbol(prop, diagnostic); + if (type) { + var name = node.name; + var prop = void 0; + if (ts.isPrivateIdentifier(name)) { + if (!type.symbol) { + return undefined; + } + prop = getPropertyOfType(type, ts.getSymbolNameForPrivateIdentifier(type.symbol, name.escapedText)); + } + else { + prop = getPropertyOfType(type, name.escapedText); + } + return prop && getExplicitTypeOfSymbol(prop, diagnostic); + } + return undefined; + } case 207 /* ParenthesizedExpression */: return getTypeOfDottedName(node.expression, diagnostic); } @@ -63206,8 +64087,12 @@ var ts; return ts.some(flow.antecedents, function (f) { return isReachableFlowNodeWorker(f, /*noCacheCheck*/ false); }); } else if (flags & 8 /* LoopLabel */) { + var antecedents = flow.antecedents; + if (antecedents === undefined || antecedents.length === 0) { + return false; + } // A loop is reachable if the control flow path that leads to the top is reachable. - flow = flow.antecedents[0]; + flow = antecedents[0]; } else if (flags & 128 /* SwitchClause */) { // The control flow path representing an unmatched value in a switch statement with @@ -63311,12 +64196,13 @@ var ts; if (flowDepth === 2000) { // We have made 2000 recursive invocations. To avoid overflowing the call stack we report an error // and disable further control flow analysis in the containing function or module body. - ts.tracing.instant("check" /* Check */, "getTypeAtFlowNode_DepthLimit", { flowId: flow.id }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "getTypeAtFlowNode_DepthLimit", { flowId: flow.id }); flowAnalysisDisabled = true; reportFlowControlError(reference); return errorType; } flowDepth++; + var sharedFlow; while (true) { var flags = flow.flags; if (flags & 4096 /* Shared */) { @@ -63329,6 +64215,7 @@ var ts; return sharedFlowTypes[i]; } } + sharedFlow = flow; } var type = void 0; if (flags & 16 /* Assignment */) { @@ -63392,9 +64279,9 @@ var ts; // simply return the non-auto declared type to reduce follow-on errors. type = convertAutoToAny(declaredType); } - if (flags & 4096 /* Shared */) { + if (sharedFlow) { // Record visited node and the associated type in the cache. - sharedFlowNodes[sharedFlowCount] = flow; + sharedFlowNodes[sharedFlowCount] = sharedFlow; sharedFlowTypes[sharedFlowCount] = type; sharedFlowCount++; } @@ -63704,6 +64591,19 @@ var ts; cache.set(key, result); return result; } + // At flow control branch or loop junctions, if the type along every antecedent code path + // is an evolving array type, we construct a combined evolving array type. Otherwise we + // finalize all evolving array types. + function getUnionOrEvolvingArrayType(types, subtypeReduction) { + if (isEvolvingArrayTypeList(types)) { + return getEvolvingArrayType(getUnionType(ts.map(types, getElementTypeOfEvolvingArrayType))); + } + var result = getUnionType(ts.sameMap(types, finalizeEvolvingArrayType), subtypeReduction); + if (result !== declaredType && result.flags & declaredType.flags & 1048576 /* Union */ && ts.arraysEqual(result.types, declaredType.types)) { + return declaredType; + } + return result; + } function isMatchingReferenceDiscriminant(expr, computedType) { var type = declaredType.flags & 1048576 /* Union */ ? declaredType : computedType; if (!(type.flags & 1048576 /* Union */) || !ts.isAccessExpression(expr)) { @@ -63720,10 +64620,13 @@ var ts; if (propName === undefined) { return type; } - var propType = getTypeOfPropertyOfType(type, propName); + var includesNullable = strictNullChecks && maybeTypeOfKind(type, 98304 /* Nullable */); + var removeNullable = includesNullable && ts.isOptionalChain(access); + var propType = getTypeOfPropertyOfType(removeNullable ? getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type, propName); if (!propType) { return type; } + propType = removeNullable ? getOptionalType(propType) : propType; var narrowedPropType = narrowType(propType); return filterType(type, function (t) { var discriminantType = getTypeOfPropertyOrIndexSignature(t, propName); @@ -64146,10 +65049,15 @@ var ts; return assignableType; } } - // If the candidate type is a subtype of the target type, narrow to the candidate type, - // if the target type is a subtype of the candidate type, narrow to the target type, - // otherwise, narrow to an intersection of the two types. - return isTypeSubtypeOf(candidate, type) ? candidate : isTypeSubtypeOf(type, candidate) ? type : getIntersectionType([type, candidate]); + // If the candidate type is a subtype of the target type, narrow to the candidate type. + // Otherwise, if the target type is assignable to the candidate type, keep the target type. + // Otherwise, if the candidate type is assignable to the target type, narrow to the candidate + // type. Otherwise, the types are completely unrelated, so narrow to an intersection of the + // two types. + return isTypeSubtypeOf(candidate, type) ? candidate : + isTypeAssignableTo(type, candidate) ? type : + isTypeAssignableTo(candidate, type) ? candidate : + getIntersectionType([type, candidate]); } function narrowTypeByCallExpression(type, callExpression, assumeTrue) { if (hasMatchingArgument(callExpression, reference)) { @@ -64324,11 +65232,19 @@ var ts; } function markAliasReferenced(symbol, location) { if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* Value */) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol)) { - if (compilerOptions.preserveConstEnums && isExportOrExportExpression(location) || !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) { - markAliasSymbolAsReferenced(symbol); - } - else { - markConstEnumAliasAsReferenced(symbol); + var target = resolveAlias(symbol); + if (target.flags & 111551 /* Value */) { + // An alias resolving to a const enum cannot be elided if (1) 'isolatedModules' is enabled + // (because the const enum value will not be inlined), or if (2) the alias is an export + // of a const enum declaration that will be preserved. + if (compilerOptions.isolatedModules || + ts.shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(location) || + !isConstEnumOrConstEnumOnlyModule(target)) { + markAliasSymbolAsReferenced(symbol); + } + else { + markConstEnumAliasAsReferenced(symbol); + } } } } @@ -64363,8 +65279,8 @@ var ts; } var localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); var sourceSymbol = localOrExportSymbol.flags & 2097152 /* Alias */ ? resolveAlias(localOrExportSymbol) : localOrExportSymbol; - if (getDeclarationNodeFlagsFromSymbol(sourceSymbol) & 134217728 /* Deprecated */ && isUncalledFunctionReference(node.parent, sourceSymbol)) { - errorOrSuggestion(/* isError */ false, node, ts.Diagnostics._0_is_deprecated, node.escapedText); + if (getDeclarationNodeFlagsFromSymbol(sourceSymbol) & 134217728 /* Deprecated */ && isUncalledFunctionReference(node, sourceSymbol)) { + addDeprecatedSuggestion(node, sourceSymbol.declarations, node.escapedText); } var declaration = localOrExportSymbol.valueDeclaration; if (localOrExportSymbol.flags & 32 /* Class */) { @@ -65422,7 +66338,7 @@ var ts; var objectLiteral = element.parent; var type = getApparentTypeOfContextualType(objectLiteral, contextFlags); if (type) { - if (!hasNonBindableDynamicName(element)) { + if (hasBindableName(element)) { // For a (non-symbol) computed property, there is no reason to look up the name // in the type. It will just be "__computed", which does not appear in any // SymbolTable. @@ -65453,7 +66369,7 @@ var ts; } function getContextualTypeForChildJsxExpression(node, child) { var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName); - // JSX expression is in children of JSX Element, we will look for an "children" atttribute (we get the name from JSX.ElementAttributesProperty) + // JSX expression is in children of JSX Element, we will look for an "children" attribute (we get the name from JSX.ElementAttributesProperty) var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node)); if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) { return undefined; @@ -65651,6 +66567,8 @@ var ts; var tag = ts.isInJSFile(parent) ? ts.getJSDocTypeTag(parent) : undefined; return tag ? getTypeFromTypeNode(tag.typeExpression.type) : getContextualType(parent, contextFlags); } + case 225 /* NonNullExpression */: + return getContextualType(parent, contextFlags); case 283 /* JsxExpression */: return getContextualTypeForJsxExpression(parent); case 280 /* JsxAttribute */: @@ -65662,10 +66580,7 @@ var ts; } return undefined; function tryFindWhenConstTypeReference(node) { - if (ts.isCallLikeExpression(node.parent)) { - return getContextualTypeForArgument(node.parent, node); - } - return undefined; + return getContextualType(node); } } function getInferenceContext(node) { @@ -65740,16 +66655,19 @@ var ts; function getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType) { var managedSym = getJsxLibraryManagedAttributes(ns); if (managedSym) { - var declaredManagedType = getDeclaredTypeOfSymbol(managedSym); + var declaredManagedType = getDeclaredTypeOfSymbol(managedSym); // fetches interface type, or initializes symbol links type parmaeters var ctorType = getStaticTypeOfReferencedJsxConstructor(context); + if (managedSym.flags & 524288 /* TypeAlias */) { + var params = getSymbolLinks(managedSym).typeParameters; + if (ts.length(params) >= 2) { + var args = fillMissingTypeArguments([ctorType, attributesType], params, 2, ts.isInJSFile(context)); + return getTypeAliasInstantiation(managedSym, args); + } + } if (ts.length(declaredManagedType.typeParameters) >= 2) { var args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.typeParameters, 2, ts.isInJSFile(context)); return createTypeReference(declaredManagedType, args); } - else if (ts.length(declaredManagedType.aliasTypeArguments) >= 2) { - var args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.aliasTypeArguments, 2, ts.isInJSFile(context)); - return getTypeAliasInstantiation(declaredManagedType.aliasSymbol, args); - } } return attributesType; } @@ -65848,8 +66766,8 @@ var ts; } var signatureList; var types = type.types; - for (var _i = 0, types_18 = types; _i < types_18.length; _i++) { - var current = types_18[_i]; + for (var _i = 0, types_20 = types; _i < types_20.length; _i++) { + var current = types_20[_i]; var signature = getContextualCallSignature(current, node); if (signature) { if (!signatureList) { @@ -65873,7 +66791,7 @@ var ts; } function checkSpreadExpression(node, checkMode) { if (languageVersion < 2 /* ES2015 */) { - checkExternalEmitHelpers(node, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 2048 /* SpreadArrays */); + checkExternalEmitHelpers(node, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 1024 /* SpreadArray */); } var arrayOrIterableType = checkExpression(node.expression, checkMode); return checkIteratedTypeOrElementType(33 /* Spread */, arrayOrIterableType, undefinedType, node.expression); @@ -65897,7 +66815,7 @@ var ts; var e = elements[i]; if (e.kind === 220 /* SpreadElement */) { if (languageVersion < 2 /* ES2015 */) { - checkExternalEmitHelpers(e, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 2048 /* SpreadArrays */); + checkExternalEmitHelpers(e, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 1024 /* SpreadArray */); } var spreadType = checkExpression(e.expression, checkMode, forceTuple); if (isArrayLikeType(spreadType)) { @@ -66279,11 +67197,7 @@ var ts; checkJsxChildren(node); return getJsxElementTypeAt(node) || anyType; } - /** - * Returns true iff the JSX element name would be a valid JS identifier, ignoring restrictions about keywords not being identifiers - */ function isUnhyphenatedJsxName(name) { - // - is the only character supported in JSX attribute names that isn't valid in JavaScript identifiers return !ts.stringContains(name, "-"); } /** @@ -67060,7 +67974,7 @@ var ts; var assignmentKind = ts.getAssignmentTargetKind(node); var apparentType = getApparentType(assignmentKind !== 0 /* None */ || isMethodAccessForCall(node) ? getWidenedType(leftType) : leftType); if (ts.isPrivateIdentifier(right)) { - checkExternalEmitHelpers(node, 1048576 /* ClassPrivateFieldGet */); + checkExternalEmitHelpers(node, 524288 /* ClassPrivateFieldGet */); } var isAnyLike = isTypeAny(apparentType) || apparentType === silentNeverType; var prop; @@ -67090,7 +68004,11 @@ var ts; } prop = getPropertyOfType(apparentType, right.escapedText); } - if (ts.isIdentifier(left) && parentSymbol && !(prop && isConstEnumOrConstEnumOnlyModule(prop))) { + // In `Foo.Bar.Baz`, 'Foo' is not referenced if 'Bar' is a const enum or a module containing only const enums. + // The exceptions are: + // 1. if 'isolatedModules' is enabled, because the const enum value will not be inlined, and + // 2. if 'preserveConstEnums' is enabled and the expression is itself an export, e.g. `export = Foo.Bar.Baz`. + if (ts.isIdentifier(left) && parentSymbol && (compilerOptions.isolatedModules || !(prop && isConstEnumOrConstEnumOnlyModule(prop)) || ts.shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(node))) { markAliasReferenced(parentSymbol, node); } var propType; @@ -67118,10 +68036,13 @@ var ts; error(node, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(apparentType)); } propType = (compilerOptions.noUncheckedIndexedAccess && !ts.isAssignmentTarget(node)) ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type; + if (compilerOptions.noPropertyAccessFromIndexSignature && ts.isPropertyAccessExpression(node)) { + error(right, ts.Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0, ts.unescapeLeadingUnderscores(right.escapedText)); + } } else { if (getDeclarationNodeFlagsFromSymbol(prop) & 134217728 /* Deprecated */ && isUncalledFunctionReference(node, prop)) { - errorOrSuggestion(/* isError */ false, right, ts.Diagnostics._0_is_deprecated, right.escapedText); + addDeprecatedSuggestion(right, prop.declarations, right.escapedText); } checkPropertyNotUsedBeforeDeclaration(prop, node, right); markPropertyAsReferenced(prop, node, left.kind === 107 /* ThisKeyword */); @@ -67140,8 +68061,7 @@ var ts; // assignment target, and the referenced property was declared as a variable, property, // accessor, or optional method. var assignmentKind = ts.getAssignmentTargetKind(node); - if (!ts.isAccessExpression(node) || - assignmentKind === 1 /* Definite */ || + if (assignmentKind === 1 /* Definite */ || prop && !(prop.flags & (3 /* Variable */ | 4 /* Property */ | 98304 /* Accessor */)) && !(prop.flags & 8192 /* Method */ && propType.flags & 1048576 /* Union */)) { return propType; } @@ -67153,7 +68073,7 @@ var ts; // and if we are in a constructor of the same class as the property declaration, assume that // the property is uninitialized at the top of the control flow. var assumeUninitialized = false; - if (strictNullChecks && strictPropertyInitialization && node.expression.kind === 107 /* ThisKeyword */) { + if (strictNullChecks && strictPropertyInitialization && ts.isAccessExpression(node) && node.expression.kind === 107 /* ThisKeyword */) { var declaration = prop && prop.valueDeclaration; if (declaration && isInstancePropertyWithoutInitializer(declaration)) { var flowContainer = getControlFlowContainer(node); @@ -67264,7 +68184,9 @@ var ts; } } if (typeHasStaticProperty(propNode.escapedText, containingType)) { - errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_is_a_static_member_of_type_1, ts.declarationNameToString(propNode), typeToString(containingType)); + var propName = ts.declarationNameToString(propNode); + var typeName = typeToString(containingType); + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead, propName, typeName, typeName + "." + propName); } else { var promisedType = getPromisedTypeOfPromise(containingType); @@ -67799,6 +68721,15 @@ var ts; inferTypes(context.inferences, checkAttrType, paramType); return getInferredTypes(context); } + function getThisArgumentType(thisArgumentNode) { + if (!thisArgumentNode) { + return voidType; + } + var thisArgumentType = checkExpression(thisArgumentNode); + return ts.isOptionalChainRoot(thisArgumentNode.parent) ? getNonNullableType(thisArgumentType) : + ts.isOptionalChain(thisArgumentNode.parent) ? removeOptionalTypeMarker(thisArgumentType) : + thisArgumentType; + } function inferTypeArguments(node, signature, args, checkMode, context) { if (ts.isJsxOpeningLikeElement(node)) { return inferJsxTypeArguments(node, signature, checkMode, context); @@ -67851,8 +68782,7 @@ var ts; var thisType = getThisTypeOfSignature(signature); if (thisType) { var thisArgumentNode = getThisArgumentOfCall(node); - var thisArgumentType = thisArgumentNode ? checkExpression(thisArgumentNode) : voidType; - inferTypes(context.inferences, thisArgumentType, thisType); + inferTypes(context.inferences, getThisArgumentType(thisArgumentNode), thisType); } for (var i = 0; i < argCount; i++) { var arg = args[i]; @@ -67964,6 +68894,9 @@ var ts; /*headMessage*/ undefined, containingMessageChain, errorOutputContainer); function checkTagNameDoesNotExpectTooManyArguments() { var _a; + if (getJsxNamespaceContainerForImplicitImport(node)) { + return true; // factory is implicitly jsx/jsxdev - assume it fits the bill, since we don't strongly look for the jsx/jsxs/jsxDEV factory APIs anywhere else (at least not yet) + } var tagType = ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node) && !isJsxIntrinsicIdentifier(node.tagName) ? checkExpression(node.tagName) : undefined; if (!tagType) { return true; @@ -68053,19 +68986,7 @@ var ts; // If the signature's 'this' type is voidType, then the check is skipped -- anything is compatible. // If the expression is a new expression, then the check is skipped. var thisArgumentNode = getThisArgumentOfCall(node); - var thisArgumentType = void 0; - if (thisArgumentNode) { - thisArgumentType = checkExpression(thisArgumentNode); - if (ts.isOptionalChainRoot(thisArgumentNode.parent)) { - thisArgumentType = getNonNullableType(thisArgumentType); - } - else if (ts.isOptionalChain(thisArgumentNode.parent)) { - thisArgumentType = removeOptionalTypeMarker(thisArgumentType); - } - } - else { - thisArgumentType = voidType; - } + var thisArgumentType = getThisArgumentType(thisArgumentNode); var errorNode = reportErrors ? (thisArgumentNode || node) : undefined; var headMessage_1 = ts.Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1; if (!checkTypeRelatedTo(thisArgumentType, thisType, relation, errorNode, headMessage_1, containingMessageChain, errorOutputContainer)) { @@ -68094,7 +69015,11 @@ var ts; } if (restType) { var spreadType = getSpreadArgumentType(args, argCount, args.length, restType, /*context*/ undefined, checkMode); - var errorNode = reportErrors ? argCount < args.length ? args[argCount] : node : undefined; + var restArgCount = args.length - argCount; + var errorNode = !reportErrors ? undefined : + restArgCount === 0 ? node : + restArgCount === 1 ? args[argCount] : + ts.setTextRangePosEnd(createSyntheticExpression(node, spreadType), args[argCount].pos, args[args.length - 1].end); if (!checkTypeRelatedTo(spreadType, restType, relation, errorNode, headMessage, /*containingMessageChain*/ undefined, errorOutputContainer)) { ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "rest parameter should have errors when reporting errors"); maybeAddMissingAwaitInfo(errorNode, spreadType, restType); @@ -68258,8 +69183,8 @@ var ts; } function getDiagnosticForCallNode(node, message, arg0, arg1, arg2, arg3) { if (ts.isCallExpression(node)) { - var _a = getDiagnosticSpanForCallNode(node), sourceFile = _a.sourceFile, start = _a.start, length_5 = _a.length; - return ts.createFileDiagnostic(sourceFile, start, length_5, message, arg0, arg1, arg2, arg3); + var _a = getDiagnosticSpanForCallNode(node), sourceFile = _a.sourceFile, start = _a.start, length_6 = _a.length; + return ts.createFileDiagnostic(sourceFile, start, length_6, message, arg0, arg1, arg2, arg3); } else { return ts.createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3); @@ -68523,11 +69448,11 @@ var ts; var chain = ts.chainDiagnosticMessages(ts.map(diags_3, function (d) { return typeof d.messageText === "string" ? d : d.messageText; }), ts.Diagnostics.No_overload_matches_this_call); // The below is a spread to guarantee we get a new (mutable) array - our `flatMap` helper tries to do "smart" optimizations where it reuses input // arrays and the emptyArray singleton where possible, which is decidedly not what we want while we're still constructing this diagnostic - var related = __spreadArrays(ts.flatMap(diags_3, function (d) { return d.relatedInformation; })); + var related = __spreadArray([], ts.flatMap(diags_3, function (d) { return d.relatedInformation; })); var diag = void 0; if (ts.every(diags_3, function (d) { return d.start === diags_3[0].start && d.length === diags_3[0].length && d.file === diags_3[0].file; })) { - var _b = diags_3[0], file = _b.file, start = _b.start, length_6 = _b.length; - diag = { file: file, start: start, length: length_6, code: chain.code, category: chain.category, messageText: chain, relatedInformation: related }; + var _b = diags_3[0], file = _b.file, start = _b.start, length_7 = _b.length; + diag = { file: file, start: start, length: length_7, code: chain.code, category: chain.category, messageText: chain, relatedInformation: related }; } else { diag = ts.createDiagnosticForNodeFromMessageChain(node, chain, related); @@ -68561,9 +69486,9 @@ var ts; var oldCandidatesForArgumentError = candidatesForArgumentError; var oldCandidateForArgumentArityError = candidateForArgumentArityError; var oldCandidateForTypeArgumentError = candidateForTypeArgumentError; - var declCount = ts.length((_a = failed.declaration) === null || _a === void 0 ? void 0 : _a.symbol.declarations); - var isOverload = declCount > 1; - var implDecl = isOverload ? ts.find(((_b = failed.declaration) === null || _b === void 0 ? void 0 : _b.symbol.declarations) || ts.emptyArray, function (d) { return ts.isFunctionLikeDeclaration(d) && ts.nodeIsPresent(d.body); }) : undefined; + var failedSignatureDeclarations = ((_b = (_a = failed.declaration) === null || _a === void 0 ? void 0 : _a.symbol) === null || _b === void 0 ? void 0 : _b.declarations) || ts.emptyArray; + var isOverload = failedSignatureDeclarations.length > 1; + var implDecl = isOverload ? ts.find(failedSignatureDeclarations, function (d) { return ts.isFunctionLikeDeclaration(d) && ts.nodeIsPresent(d.body); }) : undefined; if (implDecl) { var candidate = getSignatureFromDeclaration(implDecl); var isSingleNonGenericCandidate_1 = !candidate.typeParameters; @@ -68788,8 +69713,8 @@ var ts; if (ts.isCallChain(node)) { var nonOptionalType = getOptionalExpressionType(funcType, node.expression); callChainFlags = nonOptionalType === funcType ? 0 /* None */ : - ts.isOutermostOptionalChain(node) ? 8 /* IsOuterCallChain */ : - 4 /* IsInnerCallChain */; + ts.isOutermostOptionalChain(node) ? 16 /* IsOuterCallChain */ : + 8 /* IsInnerCallChain */; funcType = nonOptionalType; } else { @@ -68915,10 +69840,14 @@ var ts; if (!isConstructorAccessible(node, constructSignatures[0])) { return resolveErrorCall(node); } - // If the expression is a class of abstract type, then it cannot be instantiated. - // Note, only class declarations can be declared abstract. + // If the expression is a class of abstract type, or an abstract construct signature, + // then it cannot be instantiated. // In the case of a merged class-module or class-interface declaration, // only the class declaration node will have the Abstract flag set. + if (constructSignatures.some(function (signature) { return signature.flags & 4 /* Abstract */; })) { + error(node, ts.Diagnostics.Cannot_create_an_instance_of_an_abstract_class); + return resolveErrorCall(node); + } var valueDecl = expressionType.symbol && ts.getClassLikeDeclarationOfSymbol(expressionType.symbol); if (valueDecl && ts.hasSyntacticModifier(valueDecl, 128 /* Abstract */)) { error(node, ts.Diagnostics.Cannot_create_an_instance_of_an_abstract_class); @@ -69017,8 +69946,8 @@ var ts; if (apparentType.flags & 1048576 /* Union */) { var types = apparentType.types; var hasSignatures = false; - for (var _i = 0, types_19 = types; _i < types_19.length; _i++) { - var constituent = types_19[_i]; + for (var _i = 0, types_21 = types; _i < types_21.length; _i++) { + var constituent = types_21[_i]; var signatures = getSignaturesOfType(constituent, kind); if (signatures.length !== 0) { hasSignatures = true; @@ -69080,9 +70009,9 @@ var ts; ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(errorTarget, relatedInfo)); } if (ts.isCallExpression(errorTarget.parent)) { - var _b = getDiagnosticSpanForCallNode(errorTarget.parent, /* doNotIncludeArguments */ true), start = _b.start, length_7 = _b.length; + var _b = getDiagnosticSpanForCallNode(errorTarget.parent, /* doNotIncludeArguments */ true), start = _b.start, length_8 = _b.length; diagnostic.start = start; - diagnostic.length = length_7; + diagnostic.length = length_8; } diagnostics.add(diagnostic); invocationErrorRecovery(apparentType, kind, relatedInformation ? ts.addRelatedInfo(diagnostic, relatedInformation) : diagnostic); @@ -69426,7 +70355,7 @@ var ts; if (returnType.flags & 12288 /* ESSymbolLike */ && isSymbolOrSymbolForCall(node)) { return getESSymbolLikeTypeForNode(ts.walkUpParenthesizedExpressions(node.parent)); } - if (node.kind === 203 /* CallExpression */ && node.parent.kind === 233 /* ExpressionStatement */ && + if (node.kind === 203 /* CallExpression */ && !node.questionDotToken && node.parent.kind === 233 /* ExpressionStatement */ && returnType.flags & 16384 /* Void */ && getTypePredicateOfSignature(signature)) { if (!ts.isDottedName(node.expression)) { error(node.expression, ts.Diagnostics.Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name); @@ -69449,7 +70378,8 @@ var ts; function checkDeprecatedSignature(signature, node) { if (signature.declaration && signature.declaration.flags & 134217728 /* Deprecated */) { var suggestionNode = getDeprecatedSuggestionNode(node); - errorOrSuggestion(/*isError*/ false, suggestionNode, ts.Diagnostics._0_is_deprecated, signatureToString(signature)); + var name = ts.tryGetPropertyAccessOrIdentifierToString(ts.getInvokedExpression(node)); + addDeprecatedSuggestionWithSignature(suggestionNode, signature.declaration, name, signatureToString(signature)); } } function getDeprecatedSuggestionNode(node) { @@ -69575,7 +70505,7 @@ var ts; if (!checkGrammarTaggedTemplateChain(node)) checkGrammarTypeArguments(node, node.typeArguments); if (languageVersion < 2 /* ES2015 */) { - checkExternalEmitHelpers(node, 524288 /* MakeTemplateObject */); + checkExternalEmitHelpers(node, 262144 /* MakeTemplateObject */); } var signature = getResolvedSignature(node); checkDeprecatedSignature(signature, node); @@ -69770,6 +70700,10 @@ var ts; } return createTupleType(types, flags, /*readonly*/ false, ts.length(names) === ts.length(types) ? names : undefined); } + // Return the number of parameters in a signature. The rest parameter, if present, counts as one + // parameter. For example, the parameter count of (x: number, y: number, ...z: string[]) is 3 and + // the parameter count of (x: number, ...args: [number, ...string[], boolean])) is also 3. In the + // latter example, the effective rest type is [...string[], boolean]. function getParameterCount(signature) { var length = signature.parameters.length; if (signatureHasRestParameter(signature)) { @@ -69796,7 +70730,7 @@ var ts; } } if (minArgumentCount === undefined) { - if (!strongArityForUntypedJS && signature.flags & 16 /* IsUntypedSignatureInJSFile */) { + if (!strongArityForUntypedJS && signature.flags & 32 /* IsUntypedSignatureInJSFile */) { return 0; } minArgumentCount = signature.minArgumentCount; @@ -70671,8 +71605,8 @@ var ts; } if (type.flags & 3145728 /* UnionOrIntersection */) { var types = type.types; - for (var _i = 0, types_20 = types; _i < types_20.length; _i++) { - var t = types_20[_i]; + for (var _i = 0, types_22 = types; _i < types_22.length; _i++) { + var t = types_22[_i]; if (maybeTypeOfKind(t, kind)) { return true; } @@ -70736,14 +71670,33 @@ var ts; rightType = checkNonNullType(rightType, right); // TypeScript 1.0 spec (April 2014): 4.15.5 // The in operator requires the left operand to be of type Any, the String primitive type, or the Number primitive type, - // and the right operand to be of type Any, an object type, or a type parameter type. + // and the right operand to be + // + // 1. assignable to the non-primitive type, + // 2. an unconstrained type parameter, + // 3. a union or intersection including one or more type parameters, whose constituents are all assignable to the + // the non-primitive type, or are unconstrainted type parameters, or have constraints assignable to the + // non-primitive type, or + // 4. a type parameter whose constraint is + // i. an object type, + // ii. the non-primitive type, or + // iii. a union or intersection with at least one constituent assignable to an object or non-primitive type. + // + // The divergent behavior for type parameters and unions containing type parameters is a workaround for type + // parameters not being narrowable. If the right operand is a concrete type, we can error if there is any chance + // it is a primitive. But if the operand is a type parameter, it cannot be narrowed, so we don't issue an error + // unless *all* instantiations would result in an error. + // // The result is always of the Boolean primitive type. if (!(allTypesAssignableToKind(leftType, 402653316 /* StringLike */ | 296 /* NumberLike */ | 12288 /* ESSymbolLike */) || isTypeAssignableToKind(leftType, 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */ | 262144 /* TypeParameter */))) { error(left, ts.Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol); } - if (!allTypesAssignableToKind(rightType, 67108864 /* NonPrimitive */ | 58982400 /* InstantiableNonPrimitive */)) { - error(right, ts.Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter); + var rightTypeConstraint = getConstraintOfType(rightType); + if (!allTypesAssignableToKind(rightType, 67108864 /* NonPrimitive */ | 58982400 /* InstantiableNonPrimitive */) || + rightTypeConstraint && (isTypeAssignableToKind(rightType, 3145728 /* UnionOrIntersection */) && !allTypesAssignableToKind(rightTypeConstraint, 67108864 /* NonPrimitive */ | 58982400 /* InstantiableNonPrimitive */) || + !maybeTypeOfKind(rightTypeConstraint, 67108864 /* NonPrimitive */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */))) { + error(right, ts.Diagnostics.The_right_hand_side_of_an_in_expression_must_not_be_a_primitive); } return booleanType; } @@ -70900,7 +71853,7 @@ var ts; checkTypeAssignableToAndOptionallyElaborate(sourceType, targetType, target, target); } if (ts.isPrivateIdentifierPropertyAccessExpression(target)) { - checkExternalEmitHelpers(target.parent, 2097152 /* ClassPrivateFieldSet */); + checkExternalEmitHelpers(target.parent, 1048576 /* ClassPrivateFieldSet */); } return sourceType; } @@ -71006,6 +71959,10 @@ var ts; workStacks.leftType[stackIndex] = leftType; var operator = node.operatorToken.kind; if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) { + if (operator === 55 /* AmpersandAmpersandToken */) { + var parent = ts.walkUpParenthesizedExpressions(node.parent); + checkTestingKnownTruthyCallableType(node.left, leftType, ts.isIfStatement(parent) ? parent.thenStatement : undefined); + } checkTruthinessOfType(leftType, node.left); } advanceState(2 /* FinishCheck */); @@ -71447,7 +72404,7 @@ var ts; // Async generator functions prior to ESNext require the __await, __asyncDelegator, // and __asyncValues helpers if (isAsync && languageVersion < 99 /* ESNext */) { - checkExternalEmitHelpers(node, 53248 /* AsyncDelegatorIncludes */); + checkExternalEmitHelpers(node, 26624 /* AsyncDelegatorIncludes */); } // Generator functions prior to ES2015 require the __values helper if (!isAsync && languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) { @@ -71476,11 +72433,21 @@ var ts; return getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, isAsync) || anyType; } - return getContextualIterationType(2 /* Next */, func) || anyType; + var type = getContextualIterationType(2 /* Next */, func); + if (!type) { + type = anyType; + if (produceDiagnostics && noImplicitAny && !ts.expressionResultIsUnused(node)) { + var contextualType = getContextualType(node); + if (!contextualType || isTypeAny(contextualType)) { + error(node, ts.Diagnostics.yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation); + } + } + } + return type; } function checkConditionalExpression(node, checkMode) { var type = checkTruthinessExpression(node.condition); - checkTestingKnownTruthyCallableType(node.condition, node.whenTrue, type); + checkTestingKnownTruthyCallableType(node.condition, type, node.whenTrue); var type1 = checkExpression(node.whenTrue, checkMode); var type2 = checkExpression(node.whenFalse, checkMode); return getUnionType([type1, type2], 2 /* Subtype */); @@ -71861,7 +72828,7 @@ var ts; } } function checkExpression(node, checkMode, forceTuple) { - ts.tracing.push("check" /* Check */, "checkExpression", { kind: node.kind, pos: node.pos, end: node.end }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("check" /* Check */, "checkExpression", { kind: node.kind, pos: node.pos, end: node.end }); var saveCurrentNode = currentNode; currentNode = node; instantiationCount = 0; @@ -71871,7 +72838,7 @@ var ts; checkConstEnumAccess(node, type); } currentNode = saveCurrentNode; - ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); return type; } function checkConstEnumAccess(node, type) { @@ -72168,7 +73135,7 @@ var ts; if (!(functionFlags & 4 /* Invalid */)) { // Async generators prior to ESNext require the __await and __asyncGenerator helpers if ((functionFlags & 3 /* AsyncGenerator */) === 3 /* AsyncGenerator */ && languageVersion < 99 /* ESNext */) { - checkExternalEmitHelpers(node, 12288 /* AsyncGeneratorIncludes */); + checkExternalEmitHelpers(node, 6144 /* AsyncGeneratorIncludes */); } // Async functions prior to ES2017 require the __awaiter helper if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */ && languageVersion < 4 /* ES2017 */) { @@ -72523,7 +73490,7 @@ var ts; if (ts.isPrivateIdentifier(node.name)) { error(node.name, ts.Diagnostics.An_accessor_cannot_be_named_with_a_private_identifier); } - if (!hasNonBindableDynamicName(node)) { + if (hasBindableName(node)) { // TypeScript 1.0 spec (April 2014): 8.4.3 // Accessors for the same member name must specify the same accessibility. var otherKind = node.kind === 167 /* GetAccessor */ ? 168 /* SetAccessor */ : 167 /* GetAccessor */; @@ -72607,7 +73574,7 @@ var ts; var symbol = getNodeLinks(node).resolvedSymbol; if (symbol) { if (ts.some(symbol.declarations, function (d) { return isTypeDeclaration(d) && !!(d.flags & 134217728 /* Deprecated */); })) { - errorOrSuggestion(/* isError */ false, getDeprecatedSuggestionNode(node), ts.Diagnostics._0_is_deprecated, symbol.escapedName); + addDeprecatedSuggestion(getDeprecatedSuggestionNode(node), symbol.declarations, symbol.escapedName); } if (type.flags & 32 /* Enum */ && symbol.flags & 8 /* EnumMember */) { error(node, ts.Diagnostics.Enum_type_0_has_members_with_initializers_that_are_not_literals, typeToString(type)); @@ -72643,8 +73610,8 @@ var ts; var seenOptionalElement = false; var seenRestElement = false; var hasNamedElement = ts.some(elementTypes, ts.isNamedTupleMember); - for (var i = 0; i < elementTypes.length; i++) { - var e = elementTypes[i]; + for (var _i = 0, elementTypes_1 = elementTypes; _i < elementTypes_1.length; _i++) { + var e = elementTypes_1[_i]; if (e.kind !== 192 /* NamedTupleMember */ && hasNamedElement) { grammarErrorOnNode(e, ts.Diagnostics.Tuple_members_must_all_have_names_or_all_not_have_names); break; @@ -72661,19 +73628,23 @@ var ts; } } else if (flags & 4 /* Rest */) { + if (seenRestElement) { + grammarErrorOnNode(e, ts.Diagnostics.A_rest_element_cannot_follow_another_rest_element); + break; + } seenRestElement = true; } else if (flags & 2 /* Optional */) { + if (seenRestElement) { + grammarErrorOnNode(e, ts.Diagnostics.An_optional_element_cannot_follow_a_rest_element); + break; + } seenOptionalElement = true; } else if (seenOptionalElement) { grammarErrorOnNode(e, ts.Diagnostics.A_required_element_cannot_follow_an_optional_element); break; } - if (seenRestElement && i !== elementTypes.length - 1) { - grammarErrorOnNode(e, ts.Diagnostics.A_rest_element_must_be_last_in_a_tuple_type); - break; - } } ts.forEach(node.elements, checkSourceElement); getTypeFromTypeNode(node); @@ -73481,8 +74452,8 @@ var ts; } function getEntityNameForDecoratorMetadataFromTypeList(types) { var commonEntityName; - for (var _i = 0, types_21 = types; _i < types_21.length; _i++) { - var typeNode = types_21[_i]; + for (var _i = 0, types_23 = types; _i < types_23.length; _i++) { + var typeNode = types_23[_i]; while (typeNode.kind === 186 /* ParenthesizedType */ || typeNode.kind === 192 /* NamedTupleMember */) { typeNode = typeNode.type; // Skip parens if need be } @@ -73692,7 +74663,7 @@ var ts; // as well as accessors in classes/object literals checkComputedPropertyName(node.name); } - if (!hasNonBindableDynamicName(node)) { + if (hasBindableName(node)) { // first we want to check the local symbol that contain this declaration // - if node.localSymbol !== undefined - this is current declaration is exported and localSymbol points to the local symbol // - if node.localSymbol === undefined - this node is non-exported so we can just pick the result of getSymbolOfNode @@ -73733,7 +74704,7 @@ var ts; if (ts.isInJSFile(node)) { var typeTag = ts.getJSDocTypeTag(node); if (typeTag && typeTag.typeExpression && !getContextualCallSignature(getTypeFromTypeNode(typeTag.typeExpression), node)) { - error(typeTag, ts.Diagnostics.The_type_of_a_function_declaration_must_match_the_function_s_signature); + error(typeTag.typeExpression.type, ts.Diagnostics.The_type_of_a_function_declaration_must_match_the_function_s_signature); } } } @@ -73863,15 +74834,16 @@ var ts; var parent = typeParameter.parent; if (parent.kind !== 185 /* InferType */ && parent.typeParameters.every(isTypeParameterUnused)) { if (ts.tryAddToSet(seenParentsWithEveryUnused, parent)) { + var sourceFile = ts.getSourceFileOfNode(parent); var range = ts.isJSDocTemplateTag(parent) // Whole @template tag ? ts.rangeOfNode(parent) // Include the `<>` in the error message - : ts.rangeOfTypeParameters(parent.typeParameters); + : ts.rangeOfTypeParameters(sourceFile, parent.typeParameters); var only = parent.typeParameters.length === 1; var message = only ? ts.Diagnostics._0_is_declared_but_its_value_is_never_read : ts.Diagnostics.All_type_parameters_are_unused; var arg0 = only ? name : undefined; - addDiagnostic(typeParameter, 1 /* Parameter */, ts.createFileDiagnostic(ts.getSourceFileOfNode(parent), range.pos, range.end - range.pos, message, arg0)); + addDiagnostic(typeParameter, 1 /* Parameter */, ts.createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, message, arg0)); } } else { @@ -73896,11 +74868,15 @@ var ts; return ts.tryCast(ts.getRootDeclaration(node), ts.isParameter); } function isValidUnusedLocalDeclaration(declaration) { - if (ts.isBindingElement(declaration) && isIdentifierThatStartsWithUnderscore(declaration.name)) { - return !!ts.findAncestor(declaration.parent, function (ancestor) { - return ts.isArrayBindingPattern(ancestor) || ts.isVariableDeclaration(ancestor) || ts.isVariableDeclarationList(ancestor) ? false : - ts.isForOfStatement(ancestor) ? true : "quit"; - }); + if (ts.isBindingElement(declaration)) { + if (ts.isObjectBindingPattern(declaration.parent)) { + /** + * ignore starts with underscore names _ + * const { a: _a } = { a: 1 } + */ + return !!(declaration.propertyName && isIdentifierThatStartsWithUnderscore(declaration.name)); + } + return isIdentifierThatStartsWithUnderscore(declaration.name); } return ts.isAmbientModule(declaration) || (ts.isVariableDeclaration(declaration) && ts.isForInOrOfStatement(declaration.parent.parent) || isImportedDeclaration(declaration)) && isIdentifierThatStartsWithUnderscore(declaration.name); @@ -73939,7 +74915,12 @@ var ts; var name = local.valueDeclaration && ts.getNameOfDeclaration(local.valueDeclaration); if (parameter && name) { if (!ts.isParameterPropertyDeclaration(parameter, parameter.parent) && !ts.parameterIsThisKeyword(parameter) && !isIdentifierThatStartsWithUnderscore(name)) { - addDiagnostic(parameter, 1 /* Parameter */, ts.createDiagnosticForNode(name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.symbolName(local))); + if (ts.isBindingElement(declaration) && ts.isArrayBindingPattern(declaration.parent)) { + addToGroup(unusedDestructures, declaration.parent, declaration, getNodeId); + } + else { + addDiagnostic(parameter, 1 /* Parameter */, ts.createDiagnosticForNode(name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.symbolName(local))); + } } } else { @@ -74379,10 +75360,10 @@ var ts; return ts.getSelectedEffectiveModifierFlags(left, interestingFlags) === ts.getSelectedEffectiveModifierFlags(right, interestingFlags); } function checkVariableDeclaration(node) { - ts.tracing.push("check" /* Check */, "checkVariableDeclaration", { kind: node.kind, pos: node.pos, end: node.end }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("check" /* Check */, "checkVariableDeclaration", { kind: node.kind, pos: node.pos, end: node.end }); checkGrammarVariableDeclaration(node); checkVariableLikeDeclaration(node); - ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); } function checkBindingElement(node) { checkGrammarBindingElement(node); @@ -74403,23 +75384,25 @@ var ts; // Grammar checking checkGrammarStatementInAmbientContext(node); var type = checkTruthinessExpression(node.expression); - checkTestingKnownTruthyCallableType(node.expression, node.thenStatement, type); + checkTestingKnownTruthyCallableType(node.expression, type, node.thenStatement); checkSourceElement(node.thenStatement); if (node.thenStatement.kind === 231 /* EmptyStatement */) { error(node.thenStatement, ts.Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement); } checkSourceElement(node.elseStatement); } - function checkTestingKnownTruthyCallableType(condExpr, body, type) { + function checkTestingKnownTruthyCallableType(condExpr, type, body) { if (!strictNullChecks) { return; } - var testedNode = ts.isIdentifier(condExpr) - ? condExpr - : ts.isPropertyAccessExpression(condExpr) - ? condExpr.name - : undefined; - if (!testedNode) { + var location = ts.isBinaryExpression(condExpr) ? condExpr.right : condExpr; + var testedNode = ts.isIdentifier(location) ? location + : ts.isPropertyAccessExpression(location) ? location.name + : ts.isBinaryExpression(location) && ts.isIdentifier(location.right) ? location.right + : undefined; + var isPropertyExpressionCast = ts.isPropertyAccessExpression(location) + && ts.isAssertionExpression(ts.skipParentheses(location.expression)); + if (!testedNode || isPropertyExpressionCast) { return; } var possiblyFalsy = getFalsyFlags(type); @@ -74435,16 +75418,23 @@ var ts; if (callSignatures.length === 0) { return; } - var testedFunctionSymbol = getSymbolAtLocation(testedNode); - if (!testedFunctionSymbol) { + var testedSymbol = getSymbolAtLocation(testedNode); + if (!testedSymbol) { return; } - var functionIsUsedInBody = ts.forEachChild(body, function check(childNode) { + var isUsed = ts.isBinaryExpression(condExpr.parent) && isFunctionUsedInBinaryExpressionChain(condExpr.parent, testedSymbol) + || body && isFunctionUsedInConditionBody(condExpr, body, testedNode, testedSymbol); + if (!isUsed) { + error(location, ts.Diagnostics.This_condition_will_always_return_true_since_the_function_is_always_defined_Did_you_mean_to_call_it_instead); + } + } + function isFunctionUsedInConditionBody(expr, body, testedNode, testedSymbol) { + return !!ts.forEachChild(body, function check(childNode) { if (ts.isIdentifier(childNode)) { var childSymbol = getSymbolAtLocation(childNode); - if (childSymbol && childSymbol === testedFunctionSymbol) { + if (childSymbol && childSymbol === testedSymbol) { // If the test was a simple identifier, the above check is sufficient - if (ts.isIdentifier(condExpr)) { + if (ts.isIdentifier(expr)) { return true; } // Otherwise we need to ensure the symbol is called on the same target @@ -74455,13 +75445,17 @@ var ts; testedExpression.kind === 107 /* ThisKeyword */ && childExpression.kind === 107 /* ThisKeyword */) { return getSymbolAtLocation(testedExpression) === getSymbolAtLocation(childExpression); } - if (ts.isPropertyAccessExpression(testedExpression) && ts.isPropertyAccessExpression(childExpression)) { + else if (ts.isPropertyAccessExpression(testedExpression) && ts.isPropertyAccessExpression(childExpression)) { if (getSymbolAtLocation(testedExpression.name) !== getSymbolAtLocation(childExpression.name)) { return false; } childExpression = childExpression.expression; testedExpression = testedExpression.expression; } + else if (ts.isCallExpression(testedExpression) && ts.isCallExpression(childExpression)) { + childExpression = childExpression.expression; + testedExpression = testedExpression.expression; + } else { return false; } @@ -74470,9 +75464,24 @@ var ts; } return ts.forEachChild(childNode, check); }); - if (!functionIsUsedInBody) { - error(condExpr, ts.Diagnostics.This_condition_will_always_return_true_since_the_function_is_always_defined_Did_you_mean_to_call_it_instead); + } + function isFunctionUsedInBinaryExpressionChain(node, testedSymbol) { + while (ts.isBinaryExpression(node) && node.operatorToken.kind === 55 /* AmpersandAmpersandToken */) { + var isUsed = ts.forEachChild(node.right, function visit(child) { + if (ts.isIdentifier(child)) { + var symbol = getSymbolAtLocation(child); + if (symbol && symbol === testedSymbol) { + return true; + } + } + return ts.forEachChild(child, visit); + }); + if (isUsed) { + return true; + } + node = node.parent; } + return false; } function checkDoStatement(node) { // Grammar checking @@ -74525,7 +75534,7 @@ var ts; var functionFlags = ts.getFunctionFlags(ts.getContainingFunction(node)); if ((functionFlags & (4 /* Invalid */ | 2 /* Async */)) === 2 /* Async */ && languageVersion < 99 /* ESNext */) { // for..await..of in an async function or async generator function prior to ESNext requires the __asyncValues helper - checkExternalEmitHelpers(node, 32768 /* ForAwaitOfIncludes */); + checkExternalEmitHelpers(node, 16384 /* ForAwaitOfIncludes */); } } else if (compilerOptions.downlevelIteration && languageVersion < 2 /* ES2015 */) { @@ -75453,7 +76462,7 @@ var ts; // Only process instance properties with computed names here. // Static properties cannot be in conflict with indexers, // and properties with literal names were already checked. - if (!ts.hasSyntacticModifier(member, 32 /* Static */) && hasNonBindableDynamicName(member)) { + if (!ts.hasSyntacticModifier(member, 32 /* Static */) && !hasBindableName(member)) { var symbol = getSymbolOfNode(member); var propType = getTypeOfSymbol(symbol); checkIndexConstraintForProperty(symbol, propType, type, declaredStringIndexer, stringIndexType, 0 /* String */); @@ -75722,8 +76731,16 @@ var ts; // Report static side error only when instance type is assignable checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); } - if (baseConstructorType.flags & 8650752 /* TypeVariable */ && !isMixinConstructorType(staticType)) { - error(node.name || node, ts.Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any); + if (baseConstructorType.flags & 8650752 /* TypeVariable */) { + if (!isMixinConstructorType(staticType)) { + error(node.name || node, ts.Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any); + } + else { + var constructSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */); + if (constructSignatures.some(function (signature) { return signature.flags & 4 /* Abstract */; }) && !ts.hasSyntacticModifier(node, 128 /* Abstract */)) { + error(node.name || node, ts.Diagnostics.A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_be_declared_abstract); + } + } } if (!(staticBaseType.symbol && staticBaseType.symbol.flags & 32 /* Class */) && !(baseConstructorType.flags & 8650752 /* TypeVariable */)) { // When the static base type is a "class-like" constructor function (but not actually a class), we verify @@ -75740,7 +76757,7 @@ var ts; if (implementedTypeNodes) { for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) { var typeRefNode = implementedTypeNodes_1[_b]; - if (!ts.isEntityNameExpression(typeRefNode.expression)) { + if (!ts.isEntityNameExpression(typeRefNode.expression) || ts.isOptionalChain(typeRefNode.expression)) { error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments); } checkTypeReferenceNode(typeRefNode); @@ -76064,7 +77081,7 @@ var ts; checkObjectTypeForDuplicateDeclarations(node); } ts.forEach(ts.getInterfaceBaseTypeNodes(node), function (heritageElement) { - if (!ts.isEntityNameExpression(heritageElement.expression)) { + if (!ts.isEntityNameExpression(heritageElement.expression) || ts.isOptionalChain(heritageElement.expression)) { error(heritageElement.expression, ts.Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments); } checkTypeReferenceNode(heritageElement); @@ -76371,7 +77388,7 @@ var ts; if (symbol.flags & 512 /* ValueModule */ && !inAmbientContext && symbol.declarations.length > 1 - && isInstantiatedModule(node, !!compilerOptions.preserveConstEnums || !!compilerOptions.isolatedModules)) { + && isInstantiatedModule(node, ts.shouldPreserveConstEnums(compilerOptions))) { var firstNonAmbientClassOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol); if (firstNonAmbientClassOrFunc) { if (ts.getSourceFileOfNode(node) !== ts.getSourceFileOfNode(firstNonAmbientClassOrFunc)) { @@ -76535,6 +77552,7 @@ var ts; return true; } function checkAliasSymbol(node) { + var _a; var symbol = getSymbolOfNode(node); var target = resolveAlias(symbol); if (target !== unknownSymbol) { @@ -76562,8 +77580,8 @@ var ts; && !(node.flags & 8388608 /* Ambient */)) { error(node, ts.Diagnostics.Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type); } - if (ts.isImportSpecifier(node) && ts.every(target.declarations, function (d) { return !!(ts.getCombinedNodeFlags(d) & 134217728 /* Deprecated */); })) { - errorOrSuggestion(/* isError */ false, node.name, ts.Diagnostics._0_is_deprecated, symbol.escapedName); + if (ts.isImportSpecifier(node) && ((_a = target.declarations) === null || _a === void 0 ? void 0 : _a.every(function (d) { return !!(ts.getCombinedNodeFlags(d) & 134217728 /* Deprecated */); }))) { + addDeprecatedSuggestion(node.name, target.declarations, symbol.escapedName); } } } @@ -76575,7 +77593,7 @@ var ts; ts.idText(node.propertyName || node.name) === "default" && compilerOptions.esModuleInterop && moduleKind !== ts.ModuleKind.System && moduleKind < ts.ModuleKind.ES2015) { - checkExternalEmitHelpers(node, 262144 /* ImportDefault */); + checkExternalEmitHelpers(node, 131072 /* ImportDefault */); } } function checkImportDeclaration(node) { @@ -76597,7 +77615,7 @@ var ts; checkImportBinding(importClause.namedBindings); if (moduleKind !== ts.ModuleKind.System && moduleKind < ts.ModuleKind.ES2015 && compilerOptions.esModuleInterop) { // import * as ns from "foo"; - checkExternalEmitHelpers(node, 131072 /* ImportStar */); + checkExternalEmitHelpers(node, 65536 /* ImportStar */); } } else { @@ -76635,9 +77653,12 @@ var ts; checkTypeNameIsReserved(node.name, ts.Diagnostics.Import_name_cannot_be_0); } } + if (node.isTypeOnly) { + grammarErrorOnNode(node, ts.Diagnostics.An_import_alias_cannot_use_import_type); + } } else { - if (moduleKind >= ts.ModuleKind.ES2015 && !(node.flags & 8388608 /* Ambient */)) { + if (moduleKind >= ts.ModuleKind.ES2015 && !node.isTypeOnly && !(node.flags & 8388608 /* Ambient */)) { // Import equals declaration is deprecated in es6 or above grammarErrorOnNode(node, ts.Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead); } @@ -76653,7 +77674,7 @@ var ts; grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers); } if (node.moduleSpecifier && node.exportClause && ts.isNamedExports(node.exportClause) && ts.length(node.exportClause.elements) && languageVersion === 0 /* ES3 */) { - checkExternalEmitHelpers(node, 4194304 /* CreateBinding */); + checkExternalEmitHelpers(node, 2097152 /* CreateBinding */); } checkGrammarExportDeclaration(node); if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) { @@ -76684,12 +77705,12 @@ var ts; // For ES2015 modules, we emit it as a pair of `import * as a_1 ...; export { a_1 as ns }` and don't need the helper. // We only use the helper here when in esModuleInterop if (compilerOptions.esModuleInterop) { - checkExternalEmitHelpers(node, 131072 /* ImportStar */); + checkExternalEmitHelpers(node, 65536 /* ImportStar */); } } else { // export * from "foo" - checkExternalEmitHelpers(node, 65536 /* ExportStar */); + checkExternalEmitHelpers(node, 32768 /* ExportStar */); } } } @@ -76720,16 +77741,27 @@ var ts; return !!getSymbolLinks(getSymbolOfNode(declaration)).constEnumReferenced; }); } + function canConvertImportDeclarationToTypeOnly(statement) { + return ts.isImportDeclaration(statement) && + statement.importClause && + !statement.importClause.isTypeOnly && + importClauseContainsReferencedImport(statement.importClause) && + !isReferencedAliasDeclaration(statement.importClause, /*checkChildren*/ true) && + !importClauseContainsConstEnumUsedAsValue(statement.importClause); + } + function canConvertImportEqualsDeclarationToTypeOnly(statement) { + return ts.isImportEqualsDeclaration(statement) && + ts.isExternalModuleReference(statement.moduleReference) && + !statement.isTypeOnly && + getSymbolOfNode(statement).isReferenced && + !isReferencedAliasDeclaration(statement, /*checkChildren*/ false) && + !getSymbolLinks(getSymbolOfNode(statement)).constEnumReferenced; + } function checkImportsForTypeOnlyConversion(sourceFile) { for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) { var statement = _a[_i]; - if (ts.isImportDeclaration(statement) && - statement.importClause && - !statement.importClause.isTypeOnly && - importClauseContainsReferencedImport(statement.importClause) && - !isReferencedAliasDeclaration(statement.importClause, /*checkChildren*/ true) && - !importClauseContainsConstEnumUsedAsValue(statement.importClause)) { - error(statement, ts.Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is_set_to_error); + if (canConvertImportDeclarationToTypeOnly(statement) || canConvertImportEqualsDeclarationToTypeOnly(statement)) { + error(statement, ts.Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error); } } } @@ -76759,7 +77791,7 @@ var ts; moduleKind !== ts.ModuleKind.System && moduleKind < ts.ModuleKind.ES2015 && ts.idText(node.propertyName || node.name) === "default") { - checkExternalEmitHelpers(node, 262144 /* ImportDefault */); + checkExternalEmitHelpers(node, 131072 /* ImportDefault */); } } } @@ -76905,8 +77937,8 @@ var ts; return checkPropertyDeclaration(node); case 162 /* PropertySignature */: return checkPropertySignature(node); - case 174 /* FunctionType */: case 175 /* ConstructorType */: + case 174 /* FunctionType */: case 169 /* CallSignature */: case 170 /* ConstructSignature */: case 171 /* IndexSignature */: @@ -77141,6 +78173,7 @@ var ts; } } function checkDeferredNode(node) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("check" /* Check */, "checkDeferredNode", { kind: node.kind, pos: node.pos, end: node.end }); var saveCurrentNode = currentNode; currentNode = node; instantiationCount = 0; @@ -77176,15 +78209,15 @@ var ts; break; } currentNode = saveCurrentNode; + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); } function checkSourceFile(node) { - var tracingData = ["check" /* Check */, "checkSourceFile", { path: node.path }]; - ts.tracing.begin.apply(ts.tracing, tracingData); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("check" /* Check */, "checkSourceFile", { path: node.path }, /*separateBeginAndEnd*/ true); ts.performance.mark("beforeCheck"); checkSourceFileWorker(node); ts.performance.mark("afterCheck"); ts.performance.measure("Check", "beforeCheck", "afterCheck"); - ts.tracing.end.apply(ts.tracing, tracingData); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); } function unusedIsError(kind, isAmbient) { if (isAmbient) { @@ -78103,7 +79136,7 @@ var ts; // const enums and modules that contain only const enums are not considered values from the emit perspective // unless 'preserveConstEnums' option is set to true return !!(target.flags & 111551 /* Value */) && - (compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(target)); + (ts.shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target)); } function isConstEnumOrConstEnumOnlyModule(s) { return isConstEnumSymbol(s) || !!s.constEnumOnlyModule; @@ -78111,13 +79144,14 @@ var ts; function isReferencedAliasDeclaration(node, checkChildren) { if (isAliasSymbolDeclaration(node)) { var symbol = getSymbolOfNode(node); - if (symbol && getSymbolLinks(symbol).referenced) { + var links = symbol && getSymbolLinks(symbol); + if (links === null || links === void 0 ? void 0 : links.referenced) { return true; } var target = getSymbolLinks(symbol).target; // TODO: GH#18217 if (target && ts.getEffectiveModifierFlags(node) & 1 /* Export */ && target.flags & 111551 /* Value */ && - (compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(target))) { + (ts.shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) { // An `export import ... =` of a value symbol is always considered referenced return true; } @@ -78459,7 +79493,10 @@ var ts; isOptionalParameter: isOptionalParameter, moduleExportsSomeValue: moduleExportsSomeValue, isArgumentsLocalBinding: isArgumentsLocalBinding, - getExternalModuleFileFromDeclaration: getExternalModuleFileFromDeclaration, + getExternalModuleFileFromDeclaration: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.hasPossibleExternalModuleReference); + return node && getExternalModuleFileFromDeclaration(node); + }, getTypeReferenceDirectivesForEntityName: getTypeReferenceDirectivesForEntityName, getTypeReferenceDirectivesForSymbol: getTypeReferenceDirectivesForSymbol, isLiteralConstDeclaration: isLiteralConstDeclaration, @@ -78761,7 +79798,7 @@ var ts; var helpersModule = resolveHelpersModule(sourceFile, location); if (helpersModule !== unknownSymbol) { var uncheckedHelpers = helpers & ~requestedExternalEmitHelpers; - for (var helper = 1 /* FirstEmitHelper */; helper <= 4194304 /* LastEmitHelper */; helper <<= 1) { + for (var helper = 1 /* FirstEmitHelper */; helper <= 2097152 /* LastEmitHelper */; helper <<= 1) { if (uncheckedHelpers & helper) { var name = getHelperName(helper); var symbol = getSymbol(helpersModule.exports, ts.escapeLeadingUnderscores(name), 111551 /* Value */); @@ -78787,19 +79824,18 @@ var ts; case 128 /* Generator */: return "__generator"; case 256 /* Values */: return "__values"; case 512 /* Read */: return "__read"; - case 1024 /* Spread */: return "__spread"; - case 2048 /* SpreadArrays */: return "__spreadArrays"; - case 4096 /* Await */: return "__await"; - case 8192 /* AsyncGenerator */: return "__asyncGenerator"; - case 16384 /* AsyncDelegator */: return "__asyncDelegator"; - case 32768 /* AsyncValues */: return "__asyncValues"; - case 65536 /* ExportStar */: return "__exportStar"; - case 131072 /* ImportStar */: return "__importStar"; - case 262144 /* ImportDefault */: return "__importDefault"; - case 524288 /* MakeTemplateObject */: return "__makeTemplateObject"; - case 1048576 /* ClassPrivateFieldGet */: return "__classPrivateFieldGet"; - case 2097152 /* ClassPrivateFieldSet */: return "__classPrivateFieldSet"; - case 4194304 /* CreateBinding */: return "__createBinding"; + case 1024 /* SpreadArray */: return "__spreadArray"; + case 2048 /* Await */: return "__await"; + case 4096 /* AsyncGenerator */: return "__asyncGenerator"; + case 8192 /* AsyncDelegator */: return "__asyncDelegator"; + case 16384 /* AsyncValues */: return "__asyncValues"; + case 32768 /* ExportStar */: return "__exportStar"; + case 65536 /* ImportStar */: return "__importStar"; + case 131072 /* ImportDefault */: return "__importDefault"; + case 262144 /* MakeTemplateObject */: return "__makeTemplateObject"; + case 524288 /* ClassPrivateFieldGet */: return "__classPrivateFieldGet"; + case 1048576 /* ClassPrivateFieldSet */: return "__classPrivateFieldSet"; + case 2097152 /* CreateBinding */: return "__createBinding"; default: return ts.Debug.fail("Unrecognized helper"); } } @@ -78978,7 +80014,8 @@ var ts; if (flags & 128 /* Abstract */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "abstract"); } - if (node.kind !== 252 /* ClassDeclaration */) { + if (node.kind !== 252 /* ClassDeclaration */ && + node.kind !== 175 /* ConstructorType */) { if (node.kind !== 165 /* MethodDeclaration */ && node.kind !== 163 /* PropertyDeclaration */ && node.kind !== 167 /* GetAccessor */ && @@ -79088,6 +80125,7 @@ var ts; case 251 /* FunctionDeclaration */: return nodeHasAnyModifiersExcept(node, 129 /* AsyncKeyword */); case 252 /* ClassDeclaration */: + case 175 /* ConstructorType */: return nodeHasAnyModifiersExcept(node, 125 /* AbstractKeyword */); case 253 /* InterfaceDeclaration */: case 232 /* VariableStatement */: @@ -79097,7 +80135,6 @@ var ts; return nodeHasAnyModifiersExcept(node, 84 /* ConstKeyword */); default: ts.Debug.fail(); - return false; } } } @@ -79172,7 +80209,7 @@ var ts; ts.addRelatedInfo(error(parameter, ts.Diagnostics.This_parameter_is_not_allowed_with_use_strict_directive), ts.createDiagnosticForNode(useStrictDirective_1, ts.Diagnostics.use_strict_directive_used_here)); }); var diagnostics_2 = nonSimpleParameters.map(function (parameter, index) { return (index === 0 ? ts.createDiagnosticForNode(parameter, ts.Diagnostics.Non_simple_parameter_declared_here) : ts.createDiagnosticForNode(parameter, ts.Diagnostics.and_here)); }); - ts.addRelatedInfo.apply(void 0, __spreadArrays([error(useStrictDirective_1, ts.Diagnostics.use_strict_directive_cannot_be_used_with_non_simple_parameter_list)], diagnostics_2)); + ts.addRelatedInfo.apply(void 0, __spreadArray([error(useStrictDirective_1, ts.Diagnostics.use_strict_directive_cannot_be_used_with_non_simple_parameter_list)], diagnostics_2)); return true; } } @@ -79503,19 +80540,31 @@ var ts; return true; } if (forInOrOfStatement.kind === 239 /* ForOfStatement */ && forInOrOfStatement.awaitModifier) { - if ((forInOrOfStatement.flags & 32768 /* AwaitContext */) === 0 /* None */) { - // use of 'for-await-of' in non-async function + if (!(forInOrOfStatement.flags & 32768 /* AwaitContext */)) { var sourceFile = ts.getSourceFileOfNode(forInOrOfStatement); - if (!hasParseDiagnostics(sourceFile)) { - var diagnostic = ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator); - var func = ts.getContainingFunction(forInOrOfStatement); - if (func && func.kind !== 166 /* Constructor */) { - ts.Debug.assert((ts.getFunctionFlags(func) & 2 /* Async */) === 0, "Enclosing function should never be an async function."); - var relatedInfo = ts.createDiagnosticForNode(func, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async); - ts.addRelatedInfo(diagnostic, relatedInfo); - } - diagnostics.add(diagnostic); - return true; + if (ts.isInTopLevelContext(forInOrOfStatement)) { + if (!hasParseDiagnostics(sourceFile)) { + if (!ts.isEffectiveExternalModule(sourceFile, compilerOptions)) { + diagnostics.add(ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module)); + } + if ((moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System) || languageVersion < 4 /* ES2017 */) { + diagnostics.add(ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_the_target_option_is_set_to_es2017_or_higher)); + } + } + } + else { + // use of 'for-await-of' in non-async function + if (!hasParseDiagnostics(sourceFile)) { + var diagnostic = ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules); + var func = ts.getContainingFunction(forInOrOfStatement); + if (func && func.kind !== 166 /* Constructor */) { + ts.Debug.assert((ts.getFunctionFlags(func) & 2 /* Async */) === 0, "Enclosing function should never be an async function."); + var relatedInfo = ts.createDiagnosticForNode(func, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async); + ts.addRelatedInfo(diagnostic, relatedInfo); + } + diagnostics.add(diagnostic); + return true; + } } return false; } @@ -79819,7 +80868,9 @@ var ts; if (node.exclamationToken && (node.parent.parent.kind !== 232 /* VariableStatement */ || !node.type || node.initializer || node.flags & 8388608 /* Ambient */)) { var message = node.initializer ? ts.Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions - : ts.Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations; + : !node.type + ? ts.Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations + : ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context; return grammarErrorOnNode(node.exclamationToken, message); } var moduleKind = ts.getEmitModuleKind(compilerOptions); @@ -80566,7 +81617,7 @@ var ts; case 174 /* FunctionType */: return factory.updateFunctionTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode)); case 175 /* ConstructorType */: - return factory.updateConstructorTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode)); + return factory.updateConstructorTypeNode(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode)); case 176 /* TypeQuery */: return factory.updateTypeQueryNode(node, nodeVisitor(node.exprName, visitor, ts.isEntityName)); case 177 /* TypeLiteral */: @@ -80740,7 +81791,7 @@ var ts; case 259 /* NamespaceExportDeclaration */: return factory.updateNamespaceExportDeclaration(node, nodeVisitor(node.name, visitor, ts.isIdentifier)); case 260 /* ImportEqualsDeclaration */: - return factory.updateImportEqualsDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.moduleReference, visitor, ts.isModuleReference)); + return factory.updateImportEqualsDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), node.isTypeOnly, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.moduleReference, visitor, ts.isModuleReference)); case 261 /* ImportDeclaration */: return factory.updateImportDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.importClause, visitor, ts.isImportClause), nodeVisitor(node.moduleSpecifier, visitor, ts.isExpression)); case 262 /* ImportClause */: @@ -81957,7 +83008,7 @@ var ts; bindingOrAssignmentElementContainsNonLiteralComputedName(node))) { // If the right-hand value of the assignment is also an assignment target then // we need to cache the right-hand value. - initializer = ensureIdentifier(flattenContext, initializer, /*reuseIdentifierExpressions*/ false, initializer); + initializer = ensureIdentifier(flattenContext, ts.visitNode(initializer, flattenContext.visitor), /*reuseIdentifierExpressions*/ false, initializer); node = context.factory.updateVariableDeclaration(node, node.name, /*exclamationToken*/ undefined, /*type*/ undefined, initializer); } } @@ -83728,8 +84779,8 @@ var ts; // Note when updating logic here also update getEntityNameForDecoratorMetadata // so that aliases can be marked as referenced var serializedUnion; - for (var _i = 0, types_22 = types; _i < types_22.length; _i++) { - var typeNode = types_22[_i]; + for (var _i = 0, types_24 = types; _i < types_24.length; _i++) { + var typeNode = types_24[_i]; while (typeNode.kind === 186 /* ParenthesizedType */) { typeNode = typeNode.type; // Skip parens if need be } @@ -83965,7 +85016,7 @@ var ts; return !ts.nodeIsMissing(node.body); } function visitPropertyDeclaration(node) { - if (node.flags & 8388608 /* Ambient */) { + if (node.flags & 8388608 /* Ambient */ || ts.hasSyntacticModifier(node, 128 /* Abstract */)) { return undefined; } var updated = factory.updatePropertyDeclaration(node, @@ -84234,8 +85285,7 @@ var ts; */ function shouldEmitEnumDeclaration(node) { return !ts.isEnumConst(node) - || compilerOptions.preserveConstEnums - || compilerOptions.isolatedModules; + || ts.shouldPreserveConstEnums(compilerOptions); } /** * Visits an enum declaration. @@ -84369,7 +85419,7 @@ var ts; // If we can't find a parse tree node, assume the node is instantiated. return true; } - return ts.isInstantiatedModule(node, !!compilerOptions.preserveConstEnums || !!compilerOptions.isolatedModules); + return ts.isInstantiatedModule(node, ts.shouldPreserveConstEnums(compilerOptions)); } /** * Determines whether an exported declaration will have a qualified export name (e.g. `f.x` @@ -84757,6 +85807,10 @@ var ts; * @param node The import equals declaration node. */ function visitImportEqualsDeclaration(node) { + // Always elide type-only imports + if (node.isTypeOnly) { + return undefined; + } if (ts.isExternalModuleImportEqualsDeclaration(node)) { var isReferenced = resolver.isReferencedAliasDeclaration(node); // If the alias is unreferenced but we want to keep the import, replace with 'import "mod"'. @@ -85121,8 +86175,6 @@ var ts; return visitPropertyDeclaration(node); case 232 /* VariableStatement */: return visitVariableStatement(node); - case 158 /* ComputedPropertyName */: - return visitComputedPropertyName(node); case 201 /* PropertyAccessExpression */: return visitPropertyAccessExpression(node); case 214 /* PrefixUnaryExpression */: @@ -85193,7 +86245,7 @@ var ts; var savedPendingStatements = pendingStatements; pendingStatements = []; var visitedNode = ts.visitEachChild(node, visitor, context); - var statement = ts.some(pendingStatements) ? __spreadArrays([visitedNode], pendingStatements) : + var statement = ts.some(pendingStatements) ? __spreadArray([visitedNode], pendingStatements) : visitedNode; pendingStatements = savedPendingStatements; return statement; @@ -85202,7 +86254,7 @@ var ts; var node = ts.visitEachChild(name, visitor, context); if (ts.some(pendingExpressions)) { var expressions = pendingExpressions; - expressions.push(name.expression); + expressions.push(node.expression); pendingExpressions = []; node = factory.updateComputedPropertyName(node, factory.inlineExpressions(expressions)); } @@ -85304,8 +86356,13 @@ var ts; if (shouldTransformPrivateFields && ts.isPrivateIdentifierPropertyAccessExpression(node.expression)) { // Transform call expressions of private names to properly bind the `this` parameter. var _a = factory.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion), thisArg = _a.thisArg, target = _a.target; + if (ts.isCallChain(node)) { + return factory.updateCallChain(node, factory.createPropertyAccessChain(ts.visitNode(target, visitor), node.questionDotToken, "call"), + /*questionDotToken*/ undefined, + /*typeArguments*/ undefined, __spreadArray([ts.visitNode(thisArg, visitor, ts.isExpression)], ts.visitNodes(node.arguments, visitor, ts.isExpression))); + } return factory.updateCallExpression(node, factory.createPropertyAccessExpression(ts.visitNode(target, visitor), "call"), - /*typeArguments*/ undefined, __spreadArrays([ts.visitNode(thisArg, visitor, ts.isExpression)], ts.visitNodes(node.arguments, visitor, ts.isExpression))); + /*typeArguments*/ undefined, __spreadArray([ts.visitNode(thisArg, visitor, ts.isExpression)], ts.visitNodes(node.arguments, visitor, ts.isExpression))); } return ts.visitEachChild(node, visitor, context); } @@ -85326,7 +86383,7 @@ var ts; pendingExpressions = undefined; node = factory.updateBinaryExpression(node, ts.visitNode(node.left, visitorDestructuringTarget), node.operatorToken, ts.visitNode(node.right, visitor)); var expr = ts.some(pendingExpressions) ? - factory.inlineExpressions(ts.compact(__spreadArrays(pendingExpressions, [node]))) : + factory.inlineExpressions(ts.compact(__spreadArray(__spreadArray([], pendingExpressions), [node]))) : node; pendingExpressions = savedPendingExpressions; return expr; @@ -85478,7 +86535,7 @@ var ts; return ts.setTextRange(factory.createNodeArray(members), /*location*/ node.members); } function isPropertyDeclarationThatRequiresConstructorStatement(member) { - if (!ts.isPropertyDeclaration(member) || ts.hasStaticModifier(member)) { + if (!ts.isPropertyDeclaration(member) || ts.hasStaticModifier(member) || ts.hasSyntacticModifier(ts.getOriginalNode(member), 128 /* Abstract */)) { return false; } if (context.getCompilerOptions().useDefineForClassFields) { @@ -85635,8 +86692,12 @@ var ts; return undefined; } var propertyOriginalNode = ts.getOriginalNode(property); - var initializer = property.initializer || emitAssignment ? (_a = ts.visitNode(property.initializer, visitor, ts.isExpression)) !== null && _a !== void 0 ? _a : factory.createVoidZero() : ts.isParameterPropertyDeclaration(propertyOriginalNode, propertyOriginalNode.parent) && ts.isIdentifier(propertyName) ? propertyName - : factory.createVoidZero(); + if (ts.hasSyntacticModifier(propertyOriginalNode, 128 /* Abstract */)) { + return undefined; + } + var initializer = property.initializer || emitAssignment ? (_a = ts.visitNode(property.initializer, visitor, ts.isExpression)) !== null && _a !== void 0 ? _a : factory.createVoidZero() + : ts.isParameterPropertyDeclaration(propertyOriginalNode, propertyOriginalNode.parent) && ts.isIdentifier(propertyName) ? propertyName + : factory.createVoidZero(); if (emitAssignment || ts.isPrivateIdentifier(propertyName)) { var memberAccess = ts.createMemberAccessForPropertyName(factory, receiver, propertyName, /*location*/ propertyName); return factory.createAssignment(memberAccess, initializer); @@ -86370,7 +87431,7 @@ var ts; ? substitutePropertyAccessExpression(expression) : substituteElementAccessExpression(expression); return factory.createCallExpression(factory.createPropertyAccessExpression(argumentExpression, "call"), - /*typeArguments*/ undefined, __spreadArrays([ + /*typeArguments*/ undefined, __spreadArray([ factory.createThis() ], node.arguments)); } @@ -86806,7 +87867,7 @@ var ts; var visitedBindings = ts.flattenDestructuringBinding(updatedDecl, visitor, context, 1 /* ObjectRest */); var block = ts.visitNode(node.block, visitor, ts.isBlock); if (ts.some(visitedBindings)) { - block = factory.updateBlock(block, __spreadArrays([ + block = factory.updateBlock(block, __spreadArray([ factory.createVariableStatement(/*modifiers*/ undefined, visitedBindings) ], block.statements)); } @@ -87218,7 +88279,7 @@ var ts; ? substitutePropertyAccessExpression(expression) : substituteElementAccessExpression(expression); return factory.createCallExpression(factory.createPropertyAccessExpression(argumentExpression, "call"), - /*typeArguments*/ undefined, __spreadArrays([ + /*typeArguments*/ undefined, __spreadArray([ factory.createThis() ], node.arguments)); } @@ -87345,7 +88406,6 @@ var ts; if (!ts.isSimpleCopiableExpression(expression)) { thisArg = factory.createTempVariable(hoistVariableDeclaration); expression = factory.createAssignment(thisArg, expression); - // if (inParameterInitializer) tempVariableInParameter = true; } else { thisArg = expression; @@ -87381,7 +88441,6 @@ var ts; if (!ts.isSimpleCopiableExpression(leftExpression)) { capturedLeft = factory.createTempVariable(hoistVariableDeclaration); leftExpression = factory.createAssignment(capturedLeft, leftExpression); - // if (inParameterInitializer) tempVariableInParameter = true; } var rightExpression = capturedLeft; var thisArg; @@ -87394,7 +88453,6 @@ var ts; if (!ts.isSimpleCopiableExpression(rightExpression)) { thisArg = factory.createTempVariable(hoistVariableDeclaration); rightExpression = factory.createAssignment(thisArg, rightExpression); - // if (inParameterInitializer) tempVariableInParameter = true; } else { thisArg = rightExpression; @@ -87419,6 +88477,7 @@ var ts; var target = isDelete ? factory.createConditionalExpression(createNotNullCondition(leftExpression, capturedLeft, /*invert*/ true), /*questionToken*/ undefined, factory.createTrue(), /*colonToken*/ undefined, factory.createDeleteExpression(rightExpression)) : factory.createConditionalExpression(createNotNullCondition(leftExpression, capturedLeft, /*invert*/ true), /*questionToken*/ undefined, factory.createVoidZero(), /*colonToken*/ undefined, rightExpression); + ts.setTextRange(target, node); return thisArg ? factory.createSyntheticReferenceExpression(target, thisArg) : target; } function createNotNullCondition(left, right, invert) { @@ -87430,11 +88489,10 @@ var ts; if (!ts.isSimpleCopiableExpression(left)) { right = factory.createTempVariable(hoistVariableDeclaration); left = factory.createAssignment(right, left); - // if (inParameterInitializer) tempVariableInParameter = true; } - return factory.createConditionalExpression(createNotNullCondition(left, right), + return ts.setTextRange(factory.createConditionalExpression(createNotNullCondition(left, right), /*questionToken*/ undefined, right, - /*colonToken*/ undefined, ts.visitNode(node.right, visitor, ts.isExpression)); + /*colonToken*/ undefined, ts.visitNode(node.right, visitor, ts.isExpression)), node); } function visitDeleteExpression(node) { return ts.isOptionalChain(ts.skipParentheses(node.expression)) @@ -90497,7 +91555,7 @@ var ts; if (ts.isBlock(statement)) ts.setOriginalNode(loopBody, statement); var containsYield = (node.statement.transformFlags & 262144 /* ContainsYield */) !== 0; - var emitFlags = 0; + var emitFlags = 524288 /* ReuseTempVariableScope */; if (currentState.containsLexicalThis) emitFlags |= 8 /* CapturesThis */; if (containsYield && (hierarchyFacts & 4 /* AsyncFunctionBody */) !== 0) @@ -90758,7 +91816,7 @@ var ts; } function addStatementToStartOfBlock(block, statement) { var transformedStatements = ts.visitNodes(block.statements, visitor, ts.isStatement); - return factory.updateBlock(block, __spreadArrays([statement], transformedStatements)); + return factory.updateBlock(block, __spreadArray([statement], transformedStatements)); } /** * Visits a MethodDeclaration of an ObjectLiteralExpression and transforms it into a @@ -91029,7 +92087,7 @@ var ts; // [output] // new ((_a = C).bind.apply(_a, [void 0].concat(a)))() var _a = factory.createCallBinding(factory.createPropertyAccessExpression(node.expression, "bind"), hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg; - return factory.createNewExpression(factory.createFunctionApplyCall(ts.visitNode(target, visitor, ts.isExpression), thisArg, transformAndSpreadElements(factory.createNodeArray(__spreadArrays([factory.createVoidZero()], node.arguments)), /*needsUniqueCopy*/ false, /*multiLine*/ false, /*hasTrailingComma*/ false)), + return factory.createNewExpression(factory.createFunctionApplyCall(ts.visitNode(target, visitor, ts.isExpression), thisArg, transformAndSpreadElements(factory.createNodeArray(__spreadArray([factory.createVoidZero()], node.arguments)), /*needsUniqueCopy*/ false, /*multiLine*/ false, /*hasTrailingComma*/ false)), /*typeArguments*/ undefined, []); } return ts.visitEachChild(node, visitor, context); @@ -91039,55 +92097,69 @@ var ts; * * @param elements The array of Expression nodes. * @param needsUniqueCopy A value indicating whether to ensure that the result is a fresh array. + * This should be `true` when spreading into an `ArrayLiteral`, and `false` when spreading into an + * argument list. * @param multiLine A value indicating whether the result should be emitted on multiple lines. */ function transformAndSpreadElements(elements, needsUniqueCopy, multiLine, hasTrailingComma) { + // When there is no leading SpreadElement: + // // [source] // [a, ...b, c] // // [output (downlevelIteration)] - // __spread([a], b, [c]) + // __spreadArray(__spreadArray([a], __read(b)), [c]) // // [output] - // __spreadArrays([a], b, [c]) + // __spreadArray(__spreadArray([a], b), [c]) + // + // When there *is* a leading SpreadElement: + // + // [source] + // [...a, b] + // + // [output (downlevelIteration)] + // __spreadArray(__spreadArray([], __read(a)), [b]) + // + // [output] + // __spreadArray(__spreadArray([], a), [b]) + // + // NOTE: We use `isPackedArrayLiteral` below rather than just `isArrayLiteral` + // because ES2015 spread will replace _missing_ array elements with `undefined`, + // so we cannot just use an array as is. For example: + // + // `[1, ...[2, , 3]]` becomes `[1, 2, undefined, 3]` + // + // However, for packed array literals (i.e., an array literal with no OmittedExpression + // elements), we can use the array as-is. // Map spans of spread expressions into their expressions and spans of other // expressions into an array literal. var numElements = elements.length; var segments = ts.flatten(ts.spanMap(elements, partitionSpread, function (partition, visitPartition, _start, end) { return visitPartition(partition, multiLine, hasTrailingComma && end === numElements); })); - if (compilerOptions.downlevelIteration) { - if (segments.length === 1) { - var firstSegment = segments[0]; - if (isCallToHelper(firstSegment, "___spread")) { - return segments[0]; - } - } - return emitHelpers().createSpreadHelper(segments); + if (segments.length === 1) { + var firstSegment = segments[0]; + // If we don't need a unique copy, then we are spreading into an argument list for + // a CallExpression or NewExpression. When using `--downlevelIteration`, we need + // to coerce this into an array for use with `apply`, so we will use the code path + // that follows instead. + if (!needsUniqueCopy && !compilerOptions.downlevelIteration + || ts.isPackedArrayLiteral(firstSegment) // see NOTE (above) + || ts.isCallToHelper(firstSegment, "___spreadArray")) { + return segments[0]; + } + } + var helpers = emitHelpers(); + var startsWithSpread = ts.isSpreadElement(elements[0]); + var expression = startsWithSpread ? factory.createArrayLiteralExpression() : + segments[0]; + for (var i = startsWithSpread ? 0 : 1; i < segments.length; i++) { + expression = helpers.createSpreadArrayHelper(expression, compilerOptions.downlevelIteration && !ts.isPackedArrayLiteral(segments[i]) ? // see NOTE (above) + helpers.createReadHelper(segments[i], /*count*/ undefined) : + segments[i]); } - else { - if (segments.length === 1) { - var firstSegment = segments[0]; - if (!needsUniqueCopy - || isPackedArrayLiteral(firstSegment) - || isCallToHelper(firstSegment, "___spreadArrays")) { - return segments[0]; - } - } - return emitHelpers().createSpreadArraysHelper(segments); - } - } - function isPackedElement(node) { - return !ts.isOmittedExpression(node); - } - function isPackedArrayLiteral(node) { - return ts.isArrayLiteralExpression(node) && ts.every(node.elements, isPackedElement); - } - function isCallToHelper(firstSegment, helperName) { - return ts.isCallExpression(firstSegment) - && ts.isIdentifier(firstSegment.expression) - && (ts.getEmitFlags(firstSegment.expression) & 4096 /* HelperName */) - && firstSegment.expression.escapedText === helperName; + return expression; } function partitionSpread(node) { return ts.isSpreadElement(node) @@ -92370,13 +93442,13 @@ var ts; temp = declareLocal(); var initialElements = ts.visitNodes(elements, visitor, ts.isExpression, 0, numInitialElements); emitAssignment(temp, factory.createArrayLiteralExpression(leadingElement - ? __spreadArrays([leadingElement], initialElements) : initialElements)); + ? __spreadArray([leadingElement], initialElements) : initialElements)); leadingElement = undefined; } var expressions = ts.reduceLeft(elements, reduceElement, [], numInitialElements); return temp ? factory.createArrayConcatCall(temp, [factory.createArrayLiteralExpression(expressions, multiLine)]) - : ts.setTextRange(factory.createArrayLiteralExpression(leadingElement ? __spreadArrays([leadingElement], expressions) : expressions, multiLine), location); + : ts.setTextRange(factory.createArrayLiteralExpression(leadingElement ? __spreadArray([leadingElement], expressions) : expressions, multiLine), location); function reduceElement(expressions, element) { if (containsYield(element) && expressions.length > 0) { var hasAssignedTemp = temp !== undefined; @@ -92385,7 +93457,7 @@ var ts; } emitAssignment(temp, hasAssignedTemp ? factory.createArrayConcatCall(temp, [factory.createArrayLiteralExpression(expressions, multiLine)]) - : factory.createArrayLiteralExpression(leadingElement ? __spreadArrays([leadingElement], expressions) : expressions, multiLine)); + : factory.createArrayLiteralExpression(leadingElement ? __spreadArray([leadingElement], expressions) : expressions, multiLine)); leadingElement = undefined; expressions = []; } @@ -94252,14 +95324,14 @@ var ts; // define(mofactory.updateSourceFile", "module2"], function ... var updated = factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray([ factory.createExpressionStatement(factory.createCallExpression(define, - /*typeArguments*/ undefined, __spreadArrays((moduleName ? [moduleName] : []), [ + /*typeArguments*/ undefined, __spreadArray(__spreadArray([], (moduleName ? [moduleName] : [])), [ // Add the dependency array argument: // // ["require", "exports", module1", "module2", ...] - factory.createArrayLiteralExpression(jsonSourceFile ? ts.emptyArray : __spreadArrays([ + factory.createArrayLiteralExpression(jsonSourceFile ? ts.emptyArray : __spreadArray(__spreadArray([ factory.createStringLiteral("require"), factory.createStringLiteral("exports") - ], aliasedModuleNames, unaliasedModuleNames)), + ], aliasedModuleNames), unaliasedModuleNames)), // Add the module body function argument: // // function (require, exports, module1, module2) ... @@ -94269,7 +95341,7 @@ var ts; /*modifiers*/ undefined, /*asteriskToken*/ undefined, /*name*/ undefined, - /*typeParameters*/ undefined, __spreadArrays([ + /*typeParameters*/ undefined, __spreadArray([ factory.createParameterDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "require"), factory.createParameterDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "exports") ], importAliasNames), @@ -94308,11 +95380,11 @@ var ts; ts.setEmitFlags(factory.createIfStatement(factory.createStrictInequality(factory.createIdentifier("v"), factory.createIdentifier("undefined")), factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("module"), "exports"), factory.createIdentifier("v")))), 1 /* SingleLine */) ]), factory.createIfStatement(factory.createLogicalAnd(factory.createTypeCheck(factory.createIdentifier("define"), "function"), factory.createPropertyAccessExpression(factory.createIdentifier("define"), "amd")), factory.createBlock([ factory.createExpressionStatement(factory.createCallExpression(factory.createIdentifier("define"), - /*typeArguments*/ undefined, __spreadArrays((moduleName ? [moduleName] : []), [ - factory.createArrayLiteralExpression(__spreadArrays([ + /*typeArguments*/ undefined, __spreadArray(__spreadArray([], (moduleName ? [moduleName] : [])), [ + factory.createArrayLiteralExpression(__spreadArray(__spreadArray([ factory.createStringLiteral("require"), factory.createStringLiteral("exports") - ], aliasedModuleNames, unaliasedModuleNames)), + ], aliasedModuleNames), unaliasedModuleNames)), factory.createIdentifier("factory") ]))) ]))) @@ -94340,7 +95412,7 @@ var ts; /*modifiers*/ undefined, /*asteriskToken*/ undefined, /*name*/ undefined, - /*typeParameters*/ undefined, __spreadArrays([ + /*typeParameters*/ undefined, __spreadArray([ factory.createParameterDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "require"), factory.createParameterDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "exports") ], importAliasNames), @@ -94572,7 +95644,10 @@ var ts; return ts.visitEachChild(node, moduleExpressionElementVisitor, context); } function visitImportCallExpression(node) { - var argument = ts.visitNode(ts.firstOrUndefined(node.arguments), moduleExpressionElementVisitor); + var externalModuleName = ts.getExternalModuleNameLiteral(factory, node, currentSourceFile, host, resolver, compilerOptions); + var firstArgument = ts.visitNode(ts.firstOrUndefined(node.arguments), moduleExpressionElementVisitor); + // Only use the external module name if it differs from the first argument. This allows us to preserve the quote style of the argument on output. + var argument = externalModuleName && (!firstArgument || !ts.isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument; var containsLexicalThis = !!(node.transformFlags & 4096 /* ContainsLexicalThis */); switch (compilerOptions.module) { case ts.ModuleKind.AMD: @@ -95416,6 +96491,7 @@ var ts; * @param node The node to substitute. */ function substituteExpressionIdentifier(node) { + var _a, _b; if (ts.getEmitFlags(node) & 4096 /* HelperName */) { var externalHelpersModuleName = ts.getExternalHelpersModuleName(currentSourceFile); if (externalHelpersModuleName) { @@ -95437,7 +96513,7 @@ var ts; } else if (ts.isImportSpecifier(importDeclaration)) { var name = importDeclaration.propertyName || importDeclaration.name; - return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(importDeclaration.parent.parent.parent), factory.cloneNode(name)), + return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(((_b = (_a = importDeclaration.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent) || importDeclaration), factory.cloneNode(name)), /*location*/ node); } } @@ -95508,7 +96584,7 @@ var ts; var exportName = exportedNames_3[_i]; // Mark the node to prevent triggering this rule again. noSubstitution[ts.getNodeId(expression)] = true; - expression = createExportExpression(exportName, expression); + expression = factory.createParenthesizedExpression(createExportExpression(exportName, expression)); } return expression; } @@ -96679,8 +97755,12 @@ var ts; // } // }; // }); + var externalModuleName = ts.getExternalModuleNameLiteral(factory, node, currentSourceFile, host, resolver, compilerOptions); + var firstArgument = ts.visitNode(ts.firstOrUndefined(node.arguments), destructuringAndImportCallVisitor); + // Only use the external module name if it differs from the first argument. This allows us to preserve the quote style of the argument on output. + var argument = externalModuleName && (!firstArgument || !ts.isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument; return factory.createCallExpression(factory.createPropertyAccessExpression(contextObject, factory.createIdentifier("import")), - /*typeArguments*/ undefined, ts.some(node.arguments) ? [ts.visitNode(node.arguments[0], destructuringAndImportCallVisitor)] : []); + /*typeArguments*/ undefined, argument ? [argument] : []); } /** * Visits a DestructuringAssignment to flatten destructuring to exported symbols. @@ -96814,6 +97894,7 @@ var ts; * @param node The node to substitute. */ function substituteShorthandPropertyAssignment(node) { + var _a, _b; var name = node.name; if (!ts.isGeneratedIdentifier(name) && !ts.isLocalName(name)) { var importDeclaration = resolver.getReferencedImportDeclaration(name); @@ -96823,7 +97904,7 @@ var ts; /*location*/ node); } else if (ts.isImportSpecifier(importDeclaration)) { - return ts.setTextRange(factory.createPropertyAssignment(factory.cloneNode(name), factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(importDeclaration.parent.parent.parent), factory.cloneNode(importDeclaration.propertyName || importDeclaration.name))), + return ts.setTextRange(factory.createPropertyAssignment(factory.cloneNode(name), factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(((_b = (_a = importDeclaration.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent) || importDeclaration), factory.cloneNode(importDeclaration.propertyName || importDeclaration.name))), /*location*/ node); } } @@ -96855,6 +97936,7 @@ var ts; * @param node The node to substitute. */ function substituteExpressionIdentifier(node) { + var _a, _b; if (ts.getEmitFlags(node) & 4096 /* HelperName */) { var externalHelpersModuleName = ts.getExternalHelpersModuleName(currentSourceFile); if (externalHelpersModuleName) { @@ -96876,7 +97958,7 @@ var ts; /*location*/ node); } else if (ts.isImportSpecifier(importDeclaration)) { - return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(importDeclaration.parent.parent.parent), factory.cloneNode(importDeclaration.propertyName || importDeclaration.name)), + return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(((_b = (_a = importDeclaration.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent) || importDeclaration), factory.cloneNode(importDeclaration.propertyName || importDeclaration.name)), /*location*/ node); } } @@ -97025,7 +98107,7 @@ var ts; if (!ts.isExternalModule(node) || ts.some(result.statements, ts.isExternalModuleIndicator)) { return result; } - return factory.updateSourceFile(result, ts.setTextRange(factory.createNodeArray(__spreadArrays(result.statements, [ts.createEmptyExports(factory)])), result.statements)); + return factory.updateSourceFile(result, ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray([], result.statements), [ts.createEmptyExports(factory)])), result.statements)); } return node; } @@ -97154,7 +98236,8 @@ var ts; ts.isTypeAliasDeclaration(node) || ts.isConstructorDeclaration(node) || ts.isIndexSignatureDeclaration(node) || - ts.isPropertyAccessExpression(node); + ts.isPropertyAccessExpression(node) || + ts.isJSDocTypeAlias(node); } ts.canProduceDiagnostics = canProduceDiagnostics; function createGetSymbolAccessibilityDiagnosticForNodeName(node) { @@ -97252,7 +98335,7 @@ var ts; else if (ts.isImportEqualsDeclaration(node)) { return getImportEntityNameVisibilityError; } - else if (ts.isTypeAliasDeclaration(node)) { + else if (ts.isTypeAliasDeclaration(node) || ts.isJSDocTypeAlias(node)) { return getTypeAliasDeclarationVisibilityError; } else { @@ -97545,11 +98628,13 @@ var ts; typeName: node.name }; } - function getTypeAliasDeclarationVisibilityError() { + function getTypeAliasDeclarationVisibilityError(symbolAccessibilityResult) { return { - diagnosticMessage: ts.Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1, - errorNode: node.type, - typeName: node.name + diagnosticMessage: symbolAccessibilityResult.errorModuleName + ? ts.Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2 + : ts.Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1, + errorNode: ts.isJSDocTypeAlias(node) ? ts.Debug.checkDefined(node.typeExpression) : node.type, + typeName: ts.isJSDocTypeAlias(node) ? ts.getNameOfDeclaration(node) : node.name, }; } } @@ -97632,6 +98717,7 @@ var ts; reportNonlocalAugmentation: reportNonlocalAugmentation }; var errorNameNode; + var errorFallbackNode; var currentSourceFile; var refs; var libs; @@ -97701,8 +98787,8 @@ var ts; recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning)); } function reportPrivateInBaseOfClassExpression(propertyName) { - if (errorNameNode) { - context.addDiagnostic(ts.createDiagnosticForNode(errorNameNode, ts.Diagnostics.Property_0_of_exported_class_expression_may_not_be_private_or_protected, propertyName)); + if (errorNameNode || errorFallbackNode) { + context.addDiagnostic(ts.createDiagnosticForNode((errorNameNode || errorFallbackNode), ts.Diagnostics.Property_0_of_exported_class_expression_may_not_be_private_or_protected, propertyName)); } } function reportInaccessibleUniqueSymbolError() { @@ -97726,8 +98812,8 @@ var ts; } } function reportTruncationError() { - if (errorNameNode) { - context.addDiagnostic(ts.createDiagnosticForNode(errorNameNode, ts.Diagnostics.The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_type_annotation_is_needed)); + if (errorNameNode || errorFallbackNode) { + context.addDiagnostic(ts.createDiagnosticForNode((errorNameNode || errorFallbackNode), ts.Diagnostics.The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_type_annotation_is_needed)); } } function reportNonlocalAugmentation(containingFile, parentSymbol, symbol) { @@ -97740,12 +98826,12 @@ var ts; } function transformDeclarationsForJS(sourceFile, bundled) { var oldDiag = getSymbolAccessibilityDiagnostic; - getSymbolAccessibilityDiagnostic = function (s) { return ({ + getSymbolAccessibilityDiagnostic = function (s) { return (s.errorNode && ts.canProduceDiagnostics(s.errorNode) ? ts.createGetSymbolAccessibilityDiagnosticForNode(s.errorNode)(s) : ({ diagnosticMessage: s.errorModuleName ? ts.Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit : ts.Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit, errorNode: s.errorNode || sourceFile - }); }; + })); }; var result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker, bundled); getSymbolAccessibilityDiagnostic = oldDiag; return result; @@ -97833,7 +98919,7 @@ var ts; refs.forEach(referenceVisitor); emittedImports = ts.filter(combinedStatements, ts.isAnyImportSyntax); if (ts.isExternalModule(node) && (!resultHasExternalModuleIndicator || (needsScopeFixMarker && !resultHasScopeMarker))) { - combinedStatements = ts.setTextRange(factory.createNodeArray(__spreadArrays(combinedStatements, [ts.createEmptyExports(factory)])), combinedStatements); + combinedStatements = ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray([], combinedStatements), [ts.createEmptyExports(factory)])), combinedStatements); } } var updated = factory.updateSourceFile(node, combinedStatements, /*isDeclarationFile*/ true, references, getFileReferencesForUsedTypeReferences(), node.hasNoDefaultLib, getLibReferences()); @@ -98131,7 +99217,7 @@ var ts; // Rewrite external module names if necessary var specifier = ts.getExternalModuleImportEqualsDeclarationExpression(decl); return factory.updateImportEqualsDeclaration(decl, - /*decorators*/ undefined, decl.modifiers, decl.name, factory.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier(decl, specifier))); + /*decorators*/ undefined, decl.modifiers, decl.isTypeOnly, decl.name, factory.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier(decl, specifier))); } else { var oldDiag = getSymbolAccessibilityDiagnostic; @@ -98373,7 +99459,7 @@ var ts; return cleanup(factory.updateFunctionTypeNode(input, ts.visitNodes(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree))); } case 175 /* ConstructorType */: { - return cleanup(factory.updateConstructorTypeNode(input, ts.visitNodes(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree))); + return cleanup(factory.updateConstructorTypeNode(input, ensureModifiers(input), ts.visitNodes(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree))); } case 195 /* ImportType */: { if (!ts.isLiteralImportTypeNode(input)) @@ -98442,7 +99528,9 @@ var ts; diagnosticMessage: ts.Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0, errorNode: input }); }; + errorFallbackNode = input; var varDecl = factory.createVariableDeclaration(newId, /*exclamationToken*/ undefined, resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), /*initializer*/ undefined); + errorFallbackNode = undefined; var statement = factory.createVariableStatement(needsDeclare ? [factory.createModifier(133 /* DeclareKeyword */)] : [], factory.createVariableDeclarationList([varDecl], 2 /* Const */)); return [statement, factory.updateExportAssignment(input, input.decorators, input.modifiers, newId)]; } @@ -98583,7 +99671,7 @@ var ts; // 3. Some things are exported, some are not, and there's no marker - add an empty marker if (!ts.isGlobalScopeAugmentation(input) && !hasScopeMarker(lateStatements) && !resultHasScopeMarker) { if (needsScopeFixMarker) { - lateStatements = factory.createNodeArray(__spreadArrays(lateStatements, [ts.createEmptyExports(factory)])); + lateStatements = factory.createNodeArray(__spreadArray(__spreadArray([], lateStatements), [ts.createEmptyExports(factory)])); } else { lateStatements = ts.visitNodes(lateStatements, stripExportModifiers); @@ -98611,6 +99699,8 @@ var ts; } } case 252 /* ClassDeclaration */: { + errorNameNode = input.name; + errorFallbackNode = input; var modifiers = factory.createNodeArray(ensureModifiers(input)); var typeParameters = ensureTypeParams(input, input.typeParameters); var ctor = ts.getFirstConstructorWithBody(input); @@ -98650,6 +99740,8 @@ var ts; getSymbolAccessibilityDiagnostic = oldDiag_1; } var hasPrivateIdentifier = ts.some(input.members, function (member) { return !!member.name && ts.isPrivateIdentifier(member.name); }); + // When the class has at least one private identifier, create a unique constant identifier to retain the nominal typing behavior + // Prevents other classes with the same public members from being used in place of the current class var privateIdentifier = hasPrivateIdentifier ? [ factory.createPropertyDeclaration( /*decorators*/ undefined, @@ -98719,6 +99811,8 @@ var ts; if (node === input) { return node; } + errorFallbackNode = undefined; + errorNameNode = undefined; return node && ts.setOriginalNode(preserveJsDoc(node, input), input); } } @@ -99100,9 +100194,9 @@ var ts; var transformed = []; for (var _a = 0, nodes_3 = nodes; _a < nodes_3.length; _a++) { var node = nodes_3[_a]; - ts.tracing.push("emit" /* Emit */, "transformNodes", node.kind === 297 /* SourceFile */ ? { path: node.path } : { kind: node.kind, pos: node.pos, end: node.end }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "transformNodes", node.kind === 297 /* SourceFile */ ? { path: node.path } : { kind: node.kind, pos: node.pos, end: node.end }); transformed.push((allowDtsFiles ? transformation : transformRoot)(node)); - ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); } // prevent modification of the lexical environment. state = 2 /* Completed */; @@ -99273,7 +100367,7 @@ var ts; lexicalEnvironmentFunctionDeclarations || lexicalEnvironmentStatements) { if (lexicalEnvironmentFunctionDeclarations) { - statements = __spreadArrays(lexicalEnvironmentFunctionDeclarations); + statements = __spreadArray([], lexicalEnvironmentFunctionDeclarations); } if (lexicalEnvironmentVariableDeclarations) { var statement = factory.createVariableStatement( @@ -99288,10 +100382,10 @@ var ts; } if (lexicalEnvironmentStatements) { if (!statements) { - statements = __spreadArrays(lexicalEnvironmentStatements); + statements = __spreadArray([], lexicalEnvironmentStatements); } else { - statements = __spreadArrays(statements, lexicalEnvironmentStatements); + statements = __spreadArray(__spreadArray([], statements), lexicalEnvironmentStatements); } } } @@ -99514,27 +100608,24 @@ var ts; return ".js" /* Js */; } ts.getOutputExtension = getOutputExtension; - function rootDirOfOptions(configFile) { - return configFile.options.rootDir || ts.getDirectoryPath(ts.Debug.checkDefined(configFile.options.configFilePath)); - } - function getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, outputDir) { + function getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, outputDir, getCommonSourceDirectory) { return outputDir ? - ts.resolvePath(outputDir, ts.getRelativePathFromDirectory(rootDirOfOptions(configFile), inputFileName, ignoreCase)) : + ts.resolvePath(outputDir, ts.getRelativePathFromDirectory(getCommonSourceDirectory ? getCommonSourceDirectory() : getCommonSourceDirectoryOfConfig(configFile, ignoreCase), inputFileName, ignoreCase)) : inputFileName; } /* @internal */ - function getOutputDeclarationFileName(inputFileName, configFile, ignoreCase) { + function getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory) { ts.Debug.assert(!ts.fileExtensionIs(inputFileName, ".d.ts" /* Dts */) && !ts.fileExtensionIs(inputFileName, ".json" /* Json */)); - return ts.changeExtension(getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.declarationDir || configFile.options.outDir), ".d.ts" /* Dts */); + return ts.changeExtension(getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.declarationDir || configFile.options.outDir, getCommonSourceDirectory), ".d.ts" /* Dts */); } ts.getOutputDeclarationFileName = getOutputDeclarationFileName; - function getOutputJSFileName(inputFileName, configFile, ignoreCase) { + function getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory) { if (configFile.options.emitDeclarationOnly) return undefined; var isJsonFile = ts.fileExtensionIs(inputFileName, ".json" /* Json */); - var outputFileName = ts.changeExtension(getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.outDir), isJsonFile ? + var outputFileName = ts.changeExtension(getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.outDir, getCommonSourceDirectory), isJsonFile ? ".json" /* Json */ : - ts.fileExtensionIs(inputFileName, ".tsx" /* Tsx */) && configFile.options.jsx === 1 /* Preserve */ ? + configFile.options.jsx === 1 /* Preserve */ && (ts.fileExtensionIs(inputFileName, ".tsx" /* Tsx */) || ts.fileExtensionIs(inputFileName, ".jsx" /* Jsx */)) ? ".jsx" /* Jsx */ : ".js" /* Js */); return !isJsonFile || ts.comparePaths(inputFileName, outputFileName, ts.Debug.checkDefined(configFile.options.configFilePath), ignoreCase) !== 0 /* EqualTo */ ? @@ -99561,10 +100652,10 @@ var ts; addOutput(declarationMapPath); addOutput(buildInfoPath); } - function getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput) { + function getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput, getCommonSourceDirectory) { if (ts.fileExtensionIs(inputFileName, ".d.ts" /* Dts */)) return; - var js = getOutputJSFileName(inputFileName, configFile, ignoreCase); + var js = getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory); addOutput(js); if (ts.fileExtensionIs(inputFileName, ".json" /* Json */)) return; @@ -99572,7 +100663,7 @@ var ts; addOutput(js + ".map"); } if (ts.getEmitDeclarations(configFile.options)) { - var dts = getOutputDeclarationFileName(inputFileName, configFile, ignoreCase); + var dts = getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory); addOutput(dts); if (configFile.options.declarationMap) { addOutput(dts + ".map"); @@ -99580,15 +100671,47 @@ var ts; } } /*@internal*/ + function getCommonSourceDirectory(options, emittedFiles, currentDirectory, getCanonicalFileName, checkSourceFilesBelongToPath) { + var commonSourceDirectory; + if (options.rootDir) { + // If a rootDir is specified use it as the commonSourceDirectory + commonSourceDirectory = ts.getNormalizedAbsolutePath(options.rootDir, currentDirectory); + checkSourceFilesBelongToPath === null || checkSourceFilesBelongToPath === void 0 ? void 0 : checkSourceFilesBelongToPath(options.rootDir); + } + else if (options.composite && options.configFilePath) { + // Project compilations never infer their root from the input source paths + commonSourceDirectory = ts.getDirectoryPath(ts.normalizeSlashes(options.configFilePath)); + checkSourceFilesBelongToPath === null || checkSourceFilesBelongToPath === void 0 ? void 0 : checkSourceFilesBelongToPath(commonSourceDirectory); + } + else { + commonSourceDirectory = ts.computeCommonSourceDirectoryOfFilenames(emittedFiles(), currentDirectory, getCanonicalFileName); + } + if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== ts.directorySeparator) { + // Make sure directory path ends with directory separator so this string can directly + // used to replace with "" to get the relative path of the source file and the relative path doesn't + // start with / making it rooted path + commonSourceDirectory += ts.directorySeparator; + } + return commonSourceDirectory; + } + ts.getCommonSourceDirectory = getCommonSourceDirectory; + /*@internal*/ + function getCommonSourceDirectoryOfConfig(_a, ignoreCase) { + var options = _a.options, fileNames = _a.fileNames; + return getCommonSourceDirectory(options, function () { return ts.filter(fileNames, function (file) { return !(options.noEmitForJsFiles && ts.fileExtensionIsOneOf(file, ts.supportedJSExtensions)) && !ts.fileExtensionIs(file, ".d.ts" /* Dts */); }); }, ts.getDirectoryPath(ts.normalizeSlashes(ts.Debug.checkDefined(options.configFilePath))), ts.createGetCanonicalFileName(!ignoreCase)); + } + ts.getCommonSourceDirectoryOfConfig = getCommonSourceDirectoryOfConfig; + /*@internal*/ function getAllProjectOutputs(configFile, ignoreCase) { var _a = createAddOutput(), addOutput = _a.addOutput, getOutputs = _a.getOutputs; if (ts.outFile(configFile.options)) { getSingleOutputFileNames(configFile, addOutput); } else { + var getCommonSourceDirectory_1 = ts.memoize(function () { return getCommonSourceDirectoryOfConfig(configFile, ignoreCase); }); for (var _b = 0, _c = configFile.fileNames; _b < _c.length; _b++) { var inputFileName = _c[_b]; - getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput); + getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput, getCommonSourceDirectory_1); } addOutput(getTsBuildInfoEmitOutputFilePath(configFile.options)); } @@ -99614,17 +100737,18 @@ var ts; var jsFilePath = getOutputPathsForBundle(configFile.options, /*forceDtsPaths*/ false).jsFilePath; return ts.Debug.checkDefined(jsFilePath, "project " + configFile.options.configFilePath + " expected to have at least one output"); } + var getCommonSourceDirectory = ts.memoize(function () { return getCommonSourceDirectoryOfConfig(configFile, ignoreCase); }); for (var _a = 0, _b = configFile.fileNames; _a < _b.length; _a++) { var inputFileName = _b[_a]; if (ts.fileExtensionIs(inputFileName, ".d.ts" /* Dts */)) continue; - var jsFilePath = getOutputJSFileName(inputFileName, configFile, ignoreCase); + var jsFilePath = getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory); if (jsFilePath) return jsFilePath; if (ts.fileExtensionIs(inputFileName, ".json" /* Json */)) continue; if (ts.getEmitDeclarations(configFile.options)) { - return getOutputDeclarationFileName(inputFileName, configFile, ignoreCase); + return getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory); } } var buildInfoPath = getTsBuildInfoEmitOutputFilePath(configFile.options); @@ -99668,15 +100792,15 @@ var ts; sourceFiles: sourceFileOrBundle.sourceFiles.map(function (file) { return relativeToBuildInfo(ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory())); }) }; } - ts.tracing.push("emit" /* Emit */, "emitJsFileOrBundle", { jsFilePath: jsFilePath }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "emitJsFileOrBundle", { jsFilePath: jsFilePath }); emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo); - ts.tracing.pop(); - ts.tracing.push("emit" /* Emit */, "emitDeclarationFileOrBundle", { declarationFilePath: declarationFilePath }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "emitDeclarationFileOrBundle", { declarationFilePath: declarationFilePath }); emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo); - ts.tracing.pop(); - ts.tracing.push("emit" /* Emit */, "emitBuildInfo", { buildInfoPath: buildInfoPath }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "emitBuildInfo", { buildInfoPath: buildInfoPath }); emitBuildInfo(bundleBuildInfo, buildInfoPath); - ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); if (!emitSkipped && emittedFilesList) { if (!emitOnlyDtsFiles) { if (jsFilePath) { @@ -99807,6 +100931,7 @@ var ts; sourceRoot: compilerOptions.sourceRoot, mapRoot: compilerOptions.mapRoot, extendedDiagnostics: compilerOptions.extendedDiagnostics, + // Explicitly do not passthru either `inline` option }); if (forceDtsEmit && declarationTransform.transformed[0].kind === 297 /* SourceFile */) { var sourceFile = declarationTransform.transformed[0]; @@ -100039,7 +101164,7 @@ var ts; var prependNodes = ts.createPrependNodes(config.projectReferences, getCommandLine, function (f) { return host.readFile(f); }); var sourceFilesForJsEmit = createSourceFilesFromBundleBuildInfo(buildInfo.bundle, buildInfoDirectory, host); var emitHost = { - getPrependNodes: ts.memoize(function () { return __spreadArrays(prependNodes, [ownPrependInput]); }), + getPrependNodes: ts.memoize(function () { return __spreadArray(__spreadArray([], prependNodes), [ownPrependInput]); }), getCanonicalFileName: host.getCanonicalFileName, getCommonSourceDirectory: function () { return ts.getNormalizedAbsolutePath(buildInfo.bundle.commonSourceDirectory, buildInfoDirectory); }, getCompilerOptions: function () { return config.options; }, @@ -100094,7 +101219,8 @@ var ts; useCaseSensitiveFileNames: function () { return host.useCaseSensitiveFileNames(); }, getProgramBuildInfo: ts.returnUndefined, getSourceFileFromReference: ts.returnUndefined, - redirectTargetsMap: ts.createMultiMap() + redirectTargetsMap: ts.createMultiMap(), + getFileIncludeReasons: ts.notImplemented, }; emitFiles(ts.notImplementedResolver, emitHost, /*targetSourceFile*/ undefined, ts.getTransformers(config.options, customTransformers)); @@ -101236,6 +102362,7 @@ var ts; } function emitConstructorType(node) { pushNameGenerationScope(node); + emitModifiers(node, node.modifiers); writeKeyword("new"); writeSpace(); emitTypeParameters(node, node.typeParameters); @@ -101863,7 +102990,7 @@ var ts; if (isSimilarNode && currentSourceFile) { pos = ts.skipTrivia(currentSourceFile.text, pos); } - if (emitLeadingCommentsOfPosition && isSimilarNode && contextNode.pos !== startPos) { + if (isSimilarNode && contextNode.pos !== startPos) { var needsIndent = indentLeading && currentSourceFile && !ts.positionsAreOnSameLine(startPos, pos, currentSourceFile); if (needsIndent) { increaseIndent(); @@ -101874,8 +103001,9 @@ var ts; } } pos = writeTokenText(token, writer, pos); - if (emitTrailingCommentsOfPosition && isSimilarNode && contextNode.end !== pos) { - emitTrailingCommentsOfPosition(pos, /*prefixSpace*/ true); + if (isSimilarNode && contextNode.end !== pos) { + var isJsxExprContext = contextNode.kind === 283 /* JsxExpression */; + emitTrailingCommentsOfPosition(pos, /*prefixSpace*/ !isJsxExprContext, /*forceNoNewline*/ isJsxExprContext); } return pos; } @@ -102157,6 +103285,10 @@ var ts; emitModifiers(node, node.modifiers); emitTokenWithComment(99 /* ImportKeyword */, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node); writeSpace(); + if (node.isTypeOnly) { + emitTokenWithComment(149 /* TypeKeyword */, node.pos, writeKeyword, node); + writeSpace(); + } emit(node.name); writeSpace(); emitTokenWithComment(62 /* EqualsToken */, node.name.end, writePunctuation, node); @@ -102349,12 +103481,33 @@ var ts; emitExpression(node.expression); writePunctuation("}"); } + function hasTrailingCommentsAtPosition(pos) { + var result = false; + ts.forEachTrailingCommentRange((currentSourceFile === null || currentSourceFile === void 0 ? void 0 : currentSourceFile.text) || "", pos + 1, function () { return result = true; }); + return result; + } + function hasLeadingCommentsAtPosition(pos) { + var result = false; + ts.forEachLeadingCommentRange((currentSourceFile === null || currentSourceFile === void 0 ? void 0 : currentSourceFile.text) || "", pos + 1, function () { return result = true; }); + return result; + } + function hasCommentsAtPosition(pos) { + return hasTrailingCommentsAtPosition(pos) || hasLeadingCommentsAtPosition(pos); + } function emitJsxExpression(node) { - if (node.expression) { - writePunctuation("{"); + var _a; + if (node.expression || (!commentsDisabled && !ts.nodeIsSynthesized(node) && hasCommentsAtPosition(node.pos))) { // preserve empty expressions if they contain comments! + var isMultiline = currentSourceFile && !ts.nodeIsSynthesized(node) && ts.getLineAndCharacterOfPosition(currentSourceFile, node.pos).line !== ts.getLineAndCharacterOfPosition(currentSourceFile, node.end).line; + if (isMultiline) { + writer.increaseIndent(); + } + var end = emitTokenWithComment(18 /* OpenBraceToken */, node.pos, writePunctuation, node); emit(node.dotDotDotToken); emitExpression(node.expression); - writePunctuation("}"); + emitTokenWithComment(19 /* CloseBraceToken */, ((_a = node.expression) === null || _a === void 0 ? void 0 : _a.end) || end, writePunctuation, node); + if (isMultiline) { + writer.decreaseIndent(); + } } } function emitJsxTagName(node) { @@ -102428,7 +103581,7 @@ var ts; // "comment1" is not considered to be leading comment for node.initializer // but rather a trailing comment on the previous node. var initializer = node.initializer; - if (emitTrailingCommentsOfPosition && (ts.getEmitFlags(initializer) & 512 /* NoLeadingComments */) === 0) { + if ((ts.getEmitFlags(initializer) & 512 /* NoLeadingComments */) === 0) { var commentRange = ts.getCommentRange(initializer); emitTrailingCommentsOfPosition(commentRange.pos); } @@ -102671,8 +103824,8 @@ var ts; bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "reference" /* Reference */, data: directive.fileName }); writeLine(); } - for (var _d = 0, types_23 = types; _d < types_23.length; _d++) { - var directive = types_23[_d]; + for (var _d = 0, types_25 = types; _d < types_25.length; _d++) { + var directive = types_25[_d]; var pos = writer.getTextPos(); writeComment("/// "); if (bundleFileInfo) @@ -103081,9 +104234,16 @@ var ts; previousSibling = child; } // Write a trailing comma, if requested. - var hasTrailingComma = (format & 64 /* AllowTrailingComma */) && children.hasTrailingComma; - if (format & 16 /* CommaDelimited */ && hasTrailingComma) { - writePunctuation(","); + var emitFlags = previousSibling ? ts.getEmitFlags(previousSibling) : 0; + var skipTrailingComments = commentsDisabled || !!(emitFlags & 1024 /* NoTrailingComments */); + var hasTrailingComma = (children === null || children === void 0 ? void 0 : children.hasTrailingComma) && (format & 64 /* AllowTrailingComma */) && (format & 16 /* CommaDelimited */); + if (hasTrailingComma) { + if (previousSibling && !skipTrailingComments) { + emitTokenWithComment(27 /* CommaToken */, previousSibling.end, writePunctuation, previousSibling); + } + else { + writePunctuation(","); + } } // Emit any trailing comment of the last element in the list // i.e @@ -103091,8 +104251,8 @@ var ts; // 2 // /* end of element 2 */ // ]; - if (previousSibling && format & 60 /* DelimitersMask */ && previousSibling.end !== parentNode.end && !(ts.getEmitFlags(previousSibling) & 1024 /* NoTrailingComments */)) { - emitLeadingCommentsOfPosition(previousSibling.end); + if (previousSibling && parentNode.end !== previousSibling.end && (format & 60 /* DelimitersMask */) && !skipTrailingComments) { + emitLeadingCommentsOfPosition(hasTrailingComma && (children === null || children === void 0 ? void 0 : children.end) ? children.end : previousSibling.end); } // Decrease the indent, if requested. if (format & 128 /* Indented */) { @@ -103317,8 +104477,8 @@ var ts; } if (!ts.positionIsSynthesized(parentNode.pos) && !ts.nodeIsSynthesized(lastChild) && (!lastChild.parent || lastChild.parent === parentNode)) { if (preserveSourceNewlines) { - var end_2 = ts.isNodeArray(children) && !ts.positionIsSynthesized(children.end) ? children.end : lastChild.end; - return getEffectiveLines(function (includeComments) { return ts.getLinesBetweenPositionAndNextNonWhitespaceCharacter(end_2, parentNode.end, currentSourceFile, includeComments); }); + var end_1 = ts.isNodeArray(children) && !ts.positionIsSynthesized(children.end) ? children.end : lastChild.end; + return getEffectiveLines(function (includeComments) { return ts.getLinesBetweenPositionAndNextNonWhitespaceCharacter(end_1, parentNode.end, currentSourceFile, includeComments); }); } return ts.rangeEndPositionsAreOnSameLine(parentNode, lastChild, currentSourceFile) ? 0 : 1; } @@ -103436,7 +104596,8 @@ var ts; } var flags = (neverAsciiEscape ? 1 /* NeverAsciiEscape */ : 0) | (jsxAttributeEscape ? 2 /* JsxAttributeEscape */ : 0) - | (printerOptions.terminateUnterminatedLiterals ? 4 /* TerminateUnterminatedLiterals */ : 0); + | (printerOptions.terminateUnterminatedLiterals ? 4 /* TerminateUnterminatedLiterals */ : 0) + | (printerOptions.target && printerOptions.target === 99 /* ESNext */ ? 8 /* AllowNumericSeparator */ : 0); return ts.getLiteralText(node, currentSourceFile, flags); } /** @@ -104000,14 +105161,23 @@ var ts; writer.writeLine(); } } - function emitTrailingCommentsOfPosition(pos, prefixSpace) { + function emitTrailingCommentsOfPosition(pos, prefixSpace, forceNoNewline) { if (commentsDisabled) { return; } enterComment(); - forEachTrailingCommentToEmit(pos, prefixSpace ? emitTrailingComment : emitTrailingCommentOfPosition); + forEachTrailingCommentToEmit(pos, prefixSpace ? emitTrailingComment : forceNoNewline ? emitTrailingCommentOfPositionNoNewline : emitTrailingCommentOfPosition); exitComment(); } + function emitTrailingCommentOfPositionNoNewline(commentPos, commentEnd, kind) { + // trailing comments of a position are emitted at /*trailing comment1 */space/*trailing comment*/space + emitPos(commentPos); + ts.writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine); + emitPos(commentEnd); + if (kind === 2 /* SingleLineCommentTrivia */) { + writer.writeLine(); // still write a newline for single-line comments, so closing tokens aren't written on the same line + } + } function emitTrailingCommentOfPosition(commentPos, commentEnd, _kind, hasTrailingNewLine) { // trailing comments of a position are emitted at /*trailing comment1 */space/*trailing comment*/space emitPos(commentPos); @@ -104426,6 +105596,42 @@ var ts; /** Reload completely by re-reading contents of config file from disk and updating program */ ConfigFileProgramReloadLevel[ConfigFileProgramReloadLevel["Full"] = 2] = "Full"; })(ConfigFileProgramReloadLevel = ts.ConfigFileProgramReloadLevel || (ts.ConfigFileProgramReloadLevel = {})); + /** + * Updates the map of shared extended config file watches with a new set of extended config files from a base config file of the project + */ + function updateSharedExtendedConfigFileWatcher(projectPath, parsed, extendedConfigFilesMap, createExtendedConfigFileWatch, toPath) { + var _a; + var extendedConfigs = ts.arrayToMap(((_a = parsed === null || parsed === void 0 ? void 0 : parsed.options.configFile) === null || _a === void 0 ? void 0 : _a.extendedSourceFiles) || ts.emptyArray, toPath); + // remove project from all unrelated watchers + extendedConfigFilesMap.forEach(function (watcher, extendedConfigFilePath) { + if (!extendedConfigs.has(extendedConfigFilePath)) { + watcher.projects.delete(projectPath); + watcher.close(); + } + }); + // Update the extended config files watcher + extendedConfigs.forEach(function (extendedConfigFileName, extendedConfigFilePath) { + var existing = extendedConfigFilesMap.get(extendedConfigFilePath); + if (existing) { + existing.projects.add(projectPath); + } + else { + // start watching previously unseen extended config + extendedConfigFilesMap.set(extendedConfigFilePath, { + projects: new ts.Set([projectPath]), + fileWatcher: createExtendedConfigFileWatch(extendedConfigFileName, extendedConfigFilePath), + close: function () { + var existing = extendedConfigFilesMap.get(extendedConfigFilePath); + if (!existing || existing.projects.size !== 0) + return; + existing.fileWatcher.close(); + extendedConfigFilesMap.delete(extendedConfigFilePath); + }, + }); + } + }); + } + ts.updateSharedExtendedConfigFileWatcher = updateSharedExtendedConfigFileWatcher; /** * Updates the existing missing file watches with the new set of missing files after new program is created */ @@ -104477,7 +105683,7 @@ var ts; ts.updateWatchingWildcardDirectories = updateWatchingWildcardDirectories; /* @internal */ function isIgnoredFileFromWildCardWatching(_a) { - var watchedDirPath = _a.watchedDirPath, fileOrDirectory = _a.fileOrDirectory, fileOrDirectoryPath = _a.fileOrDirectoryPath, configFileName = _a.configFileName, options = _a.options, configFileSpecs = _a.configFileSpecs, program = _a.program, extraFileExtensions = _a.extraFileExtensions, currentDirectory = _a.currentDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, writeLog = _a.writeLog; + var watchedDirPath = _a.watchedDirPath, fileOrDirectory = _a.fileOrDirectory, fileOrDirectoryPath = _a.fileOrDirectoryPath, configFileName = _a.configFileName, options = _a.options, program = _a.program, extraFileExtensions = _a.extraFileExtensions, currentDirectory = _a.currentDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, writeLog = _a.writeLog; var newPath = ts.removeIgnoredPath(fileOrDirectoryPath); if (!newPath) { writeLog("Project: " + configFileName + " Detected ignored path: " + fileOrDirectory); @@ -104492,7 +105698,7 @@ var ts; writeLog("Project: " + configFileName + " Detected file add/remove of non supported extension: " + fileOrDirectory); return true; } - if (ts.isExcludedFile(fileOrDirectory, configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), useCaseSensitiveFileNames, currentDirectory)) { + if (ts.isExcludedFile(fileOrDirectory, options.configFile.configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), useCaseSensitiveFileNames, currentDirectory)) { writeLog("Project: " + configFileName + " Detected excluded file: " + fileOrDirectory); return true; } @@ -104543,86 +105749,97 @@ var ts; WatchLogLevel[WatchLogLevel["TriggerOnly"] = 1] = "TriggerOnly"; WatchLogLevel[WatchLogLevel["Verbose"] = 2] = "Verbose"; })(WatchLogLevel = ts.WatchLogLevel || (ts.WatchLogLevel = {})); - function getWatchFactory(watchLogLevel, log, getDetailWatchInfo) { - return getWatchFactoryWith(watchLogLevel, log, getDetailWatchInfo, watchFile, watchDirectory); - } - ts.getWatchFactory = getWatchFactory; - function getWatchFactoryWith(watchLogLevel, log, getDetailWatchInfo, watchFile, watchDirectory) { - var createFileWatcher = getCreateFileWatcher(watchLogLevel, watchFile); - var createFilePathWatcher = watchLogLevel === WatchLogLevel.None ? watchFilePath : createFileWatcher; - var createDirectoryWatcher = getCreateFileWatcher(watchLogLevel, watchDirectory); - if (watchLogLevel === WatchLogLevel.Verbose && ts.sysLog === ts.noop) { - ts.setSysLog(function (s) { return log(s); }); - } - return { - watchFile: function (host, file, callback, pollingInterval, options, detailInfo1, detailInfo2) { - return createFileWatcher(host, file, callback, pollingInterval, options, /*passThrough*/ undefined, detailInfo1, detailInfo2, watchFile, log, "FileWatcher", getDetailWatchInfo); - }, - watchFilePath: function (host, file, callback, pollingInterval, options, path, detailInfo1, detailInfo2) { - return createFilePathWatcher(host, file, callback, pollingInterval, options, path, detailInfo1, detailInfo2, watchFile, log, "FileWatcher", getDetailWatchInfo); - }, - watchDirectory: function (host, directory, callback, flags, options, detailInfo1, detailInfo2) { - return createDirectoryWatcher(host, directory, callback, flags, options, /*passThrough*/ undefined, detailInfo1, detailInfo2, watchDirectory, log, "DirectoryWatcher", getDetailWatchInfo); - } + function getWatchFactory(host, watchLogLevel, log, getDetailWatchInfo) { + ts.setSysLog(watchLogLevel === WatchLogLevel.Verbose ? log : ts.noop); + var plainInvokeFactory = { + watchFile: function (file, callback, pollingInterval, options) { return host.watchFile(file, callback, pollingInterval, options); }, + watchDirectory: function (directory, callback, flags, options) { return host.watchDirectory(directory, callback, (flags & 1 /* Recursive */) !== 0, options); }, }; - } - function watchFile(host, file, callback, pollingInterval, options) { - return host.watchFile(file, callback, pollingInterval, options); - } - function watchFilePath(host, file, callback, pollingInterval, options, path) { - return watchFile(host, file, function (fileName, eventKind) { return callback(fileName, eventKind, path); }, pollingInterval, options); - } - function watchDirectory(host, directory, callback, flags, options) { - return host.watchDirectory(directory, callback, (flags & 1 /* Recursive */) !== 0, options); - } - function getCreateFileWatcher(watchLogLevel, addWatch) { - switch (watchLogLevel) { - case WatchLogLevel.None: - return addWatch; - case WatchLogLevel.TriggerOnly: - return createFileWatcherWithTriggerLogging; - case WatchLogLevel.Verbose: - return addWatch === watchDirectory ? createDirectoryWatcherWithLogging : createFileWatcherWithLogging; - } - } - function createFileWatcherWithLogging(host, file, cb, flags, options, passThrough, detailInfo1, detailInfo2, addWatch, log, watchCaption, getDetailWatchInfo) { - log(watchCaption + ":: Added:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)); - var watcher = createFileWatcherWithTriggerLogging(host, file, cb, flags, options, passThrough, detailInfo1, detailInfo2, addWatch, log, watchCaption, getDetailWatchInfo); - return { - close: function () { - log(watchCaption + ":: Close:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)); - watcher.close(); - } - }; - } - function createDirectoryWatcherWithLogging(host, file, cb, flags, options, passThrough, detailInfo1, detailInfo2, addWatch, log, watchCaption, getDetailWatchInfo) { - var watchInfo = watchCaption + ":: Added:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo); - log(watchInfo); - var start = ts.timestamp(); - var watcher = createFileWatcherWithTriggerLogging(host, file, cb, flags, options, passThrough, detailInfo1, detailInfo2, addWatch, log, watchCaption, getDetailWatchInfo); - var elapsed = ts.timestamp() - start; - log("Elapsed:: " + elapsed + "ms " + watchInfo); + var triggerInvokingFactory = watchLogLevel !== WatchLogLevel.None ? + { + watchFile: createTriggerLoggingAddWatch("watchFile"), + watchDirectory: createTriggerLoggingAddWatch("watchDirectory") + } : + undefined; + var factory = watchLogLevel === WatchLogLevel.Verbose ? + { + watchFile: createFileWatcherWithLogging, + watchDirectory: createDirectoryWatcherWithLogging + } : + triggerInvokingFactory || plainInvokeFactory; + var excludeWatcherFactory = watchLogLevel === WatchLogLevel.Verbose ? + createExcludeWatcherWithLogging : + ts.returnNoopFileWatcher; return { - close: function () { - var watchInfo = watchCaption + ":: Close:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo); - log(watchInfo); - var start = ts.timestamp(); - watcher.close(); - var elapsed = ts.timestamp() - start; - log("Elapsed:: " + elapsed + "ms " + watchInfo); - } + watchFile: createExcludeHandlingAddWatch("watchFile"), + watchDirectory: createExcludeHandlingAddWatch("watchDirectory") }; - } - function createFileWatcherWithTriggerLogging(host, file, cb, flags, options, passThrough, detailInfo1, detailInfo2, addWatch, log, watchCaption, getDetailWatchInfo) { - return addWatch(host, file, function (fileName, cbOptional) { - var triggerredInfo = watchCaption + ":: Triggered with " + fileName + " " + (cbOptional !== undefined ? cbOptional : "") + ":: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo); - log(triggerredInfo); + function createExcludeHandlingAddWatch(key) { + return function (file, cb, flags, options, detailInfo1, detailInfo2) { + var _a; + return !ts.matchesExclude(file, key === "watchFile" ? options === null || options === void 0 ? void 0 : options.excludeFiles : options === null || options === void 0 ? void 0 : options.excludeDirectories, useCaseSensitiveFileNames(), ((_a = host.getCurrentDirectory) === null || _a === void 0 ? void 0 : _a.call(host)) || "") ? + factory[key].call(/*thisArgs*/ undefined, file, cb, flags, options, detailInfo1, detailInfo2) : + excludeWatcherFactory(file, flags, options, detailInfo1, detailInfo2); + }; + } + function useCaseSensitiveFileNames() { + return typeof host.useCaseSensitiveFileNames === "boolean" ? + host.useCaseSensitiveFileNames : + host.useCaseSensitiveFileNames(); + } + function createExcludeWatcherWithLogging(file, flags, options, detailInfo1, detailInfo2) { + log("ExcludeWatcher:: Added:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)); + return { + close: function () { return log("ExcludeWatcher:: Close:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)); } + }; + } + function createFileWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) { + log("FileWatcher:: Added:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)); + var watcher = triggerInvokingFactory.watchFile(file, cb, flags, options, detailInfo1, detailInfo2); + return { + close: function () { + log("FileWatcher:: Close:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)); + watcher.close(); + } + }; + } + function createDirectoryWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) { + var watchInfo = "DirectoryWatcher:: Added:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo); + log(watchInfo); var start = ts.timestamp(); - cb(fileName, cbOptional, passThrough); + var watcher = triggerInvokingFactory.watchDirectory(file, cb, flags, options, detailInfo1, detailInfo2); var elapsed = ts.timestamp() - start; - log("Elapsed:: " + elapsed + "ms " + triggerredInfo); - }, flags, options); + log("Elapsed:: " + elapsed + "ms " + watchInfo); + return { + close: function () { + var watchInfo = "DirectoryWatcher:: Close:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo); + log(watchInfo); + var start = ts.timestamp(); + watcher.close(); + var elapsed = ts.timestamp() - start; + log("Elapsed:: " + elapsed + "ms " + watchInfo); + } + }; + } + function createTriggerLoggingAddWatch(key) { + return function (file, cb, flags, options, detailInfo1, detailInfo2) { return plainInvokeFactory[key].call(/*thisArgs*/ undefined, file, function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var triggerredInfo = (key === "watchFile" ? "FileWatcher" : "DirectoryWatcher") + ":: Triggered with " + args[0] + " " + (args[1] !== undefined ? args[1] : "") + ":: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo); + log(triggerredInfo); + var start = ts.timestamp(); + cb.call.apply(cb, __spreadArray([/*thisArg*/ undefined], args)); + var elapsed = ts.timestamp() - start; + log("Elapsed:: " + elapsed + "ms " + triggerredInfo); + }, flags, options, detailInfo1, detailInfo2); }; + } + function getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo) { + return "WatchInfo: " + file + " " + flags + " " + JSON.stringify(options) + " " + (getDetailWatchInfo ? getDetailWatchInfo(detailInfo1, detailInfo2) : detailInfo2 === undefined ? detailInfo1 : detailInfo1 + " " + detailInfo2); + } } + ts.getWatchFactory = getWatchFactory; function getFallbackOptions(options) { var fallbackPolling = options === null || options === void 0 ? void 0 : options.fallbackPolling; return { @@ -104632,9 +105849,6 @@ var ts; }; } ts.getFallbackOptions = getFallbackOptions; - function getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo) { - return "WatchInfo: " + file + " " + flags + " " + JSON.stringify(options) + " " + (getDetailWatchInfo ? getDetailWatchInfo(detailInfo1, detailInfo2) : detailInfo2 === undefined ? detailInfo1 : detailInfo1 + " " + detailInfo2); - } function closeFileWatcherOf(objWithWatcher) { objWithWatcher.watcher.close(); } @@ -104989,7 +106203,7 @@ var ts; var lineEnd = i < lastLineInFile ? ts.getPositionOfLineAndCharacter(file, i + 1, 0) : file.text.length; var lineContent = file.text.slice(lineStart, lineEnd); lineContent = lineContent.replace(/\s+$/g, ""); // trim from end - lineContent = lineContent.replace("\t", " "); // convert tabs to single spaces + lineContent = lineContent.replace(/\t/g, " "); // convert tabs to single spaces // Output the gutter and the actual contents of the line. context += indent + formatColorAndReset(ts.padLeft(i + 1 + "", gutterWidth), gutterStyleSequence) + gutterSeparator; context += lineContent + host.getNewLine(); @@ -105043,18 +106257,18 @@ var ts; if (diagnostic.file) { output += host.getNewLine(); output += formatCodeSpan(diagnostic.file, diagnostic.start, diagnostic.length, "", getCategoryFormat(diagnostic.category), host); // TODO: GH#18217 - if (diagnostic.relatedInformation) { - output += host.getNewLine(); - for (var _a = 0, _b = diagnostic.relatedInformation; _a < _b.length; _a++) { - var _c = _b[_a], file = _c.file, start = _c.start, length_8 = _c.length, messageText = _c.messageText; - if (file) { - output += host.getNewLine(); - output += halfIndent + formatLocation(file, start, host); // TODO: GH#18217 - output += formatCodeSpan(file, start, length_8, indent, ForegroundColorEscapeSequences.Cyan, host); // TODO: GH#18217 - } + } + if (diagnostic.relatedInformation) { + output += host.getNewLine(); + for (var _a = 0, _b = diagnostic.relatedInformation; _a < _b.length; _a++) { + var _c = _b[_a], file = _c.file, start = _c.start, length_9 = _c.length, messageText = _c.messageText; + if (file) { output += host.getNewLine(); - output += indent + flattenDiagnosticMessageText(messageText, host.getNewLine()); + output += halfIndent + formatLocation(file, start, host); // TODO: GH#18217 + output += formatCodeSpan(file, start, length_9, indent, ForegroundColorEscapeSequences.Cyan, host); // TODO: GH#18217 } + output += host.getNewLine(); + output += indent + flattenDiagnosticMessageText(messageText, host.getNewLine()); } } output += host.getNewLine(); @@ -105140,6 +106354,56 @@ var ts; } /* @internal */ ts.inferredTypesContainingFile = "__inferred type names__.ts"; + /*@internal*/ + function isReferencedFile(reason) { + switch (reason === null || reason === void 0 ? void 0 : reason.kind) { + case ts.FileIncludeKind.Import: + case ts.FileIncludeKind.ReferenceFile: + case ts.FileIncludeKind.TypeReferenceDirective: + case ts.FileIncludeKind.LibReferenceDirective: + return true; + default: + return false; + } + } + ts.isReferencedFile = isReferencedFile; + /*@internal*/ + function isReferenceFileLocation(location) { + return location.pos !== undefined; + } + ts.isReferenceFileLocation = isReferenceFileLocation; + /*@internal*/ + function getReferencedFileLocation(getSourceFileByPath, ref) { + var _a, _b, _c; + var _d, _e, _f, _g; + var file = ts.Debug.checkDefined(getSourceFileByPath(ref.file)); + var kind = ref.kind, index = ref.index; + var pos, end, packageId; + switch (kind) { + case ts.FileIncludeKind.Import: + var importLiteral = getModuleNameStringLiteralAt(file, index); + packageId = (_e = (_d = file.resolvedModules) === null || _d === void 0 ? void 0 : _d.get(importLiteral.text)) === null || _e === void 0 ? void 0 : _e.packageId; + if (importLiteral.pos === -1) + return { file: file, packageId: packageId, text: importLiteral.text }; + pos = ts.skipTrivia(file.text, importLiteral.pos); + end = importLiteral.end; + break; + case ts.FileIncludeKind.ReferenceFile: + (_a = file.referencedFiles[index], pos = _a.pos, end = _a.end); + break; + case ts.FileIncludeKind.TypeReferenceDirective: + (_b = file.typeReferenceDirectives[index], pos = _b.pos, end = _b.end); + packageId = (_g = (_f = file.resolvedTypeReferenceDirectiveNames) === null || _f === void 0 ? void 0 : _f.get(ts.toFileNameLowerCase(file.typeReferenceDirectives[index].fileName))) === null || _g === void 0 ? void 0 : _g.packageId; + break; + case ts.FileIncludeKind.LibReferenceDirective: + (_c = file.libReferenceDirectives[index], pos = _c.pos, end = _c.end); + break; + default: + return ts.Debug.assertNever(kind); + } + return { file: file, pos: pos, end: end, packageId: packageId }; + } + ts.getReferencedFileLocation = getReferencedFileLocation; /** * Determines if program structure is upto date or needs to be recreated */ @@ -105214,7 +106478,7 @@ var ts; } ts.isProgramUptoDate = isProgramUptoDate; function getConfigFileParsingDiagnostics(configFileParseResult) { - return configFileParseResult.options.configFile ? __spreadArrays(configFileParseResult.options.configFile.parseDiagnostics, configFileParseResult.errors) : + return configFileParseResult.options.configFile ? __spreadArray(__spreadArray([], configFileParseResult.options.configFile.parseDiagnostics), configFileParseResult.errors) : configFileParseResult.errors; } ts.getConfigFileParsingDiagnostics = getConfigFileParsingDiagnostics; @@ -105241,7 +106505,7 @@ var ts; }; } function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) { - var _a, _b; + var _a, _b, _c; var createProgramOptions = ts.isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions; // TODO: GH#18217 var rootNames = createProgramOptions.rootNames, options = createProgramOptions.options, configFileParsingDiagnostics = createProgramOptions.configFileParsingDiagnostics, projectReferences = createProgramOptions.projectReferences; var oldProgram = createProgramOptions.oldProgram; @@ -105254,12 +106518,11 @@ var ts; var noDiagnosticsTypeChecker; var classifiableNames; var ambientModuleNameToUnmodifiedFileName = new ts.Map(); - // Todo:: Use this to report why file was included in --extendedDiagnostics - var refFileMap; + var fileReasons = ts.createMultiMap(); var cachedBindAndCheckDiagnosticsForFile = {}; var cachedDeclarationDiagnosticsForFile = {}; var resolvedTypeReferenceDirectives = new ts.Map(); - var fileProcessingDiagnostics = ts.createDiagnosticCollection(); + var fileProcessingDiagnostics; // The below settings are to track if a .js file should be add to the program if loaded via searching under node_modules. // This works as imported modules are discovered recursively in a depth first manner, specifically: // - For each root file, findSourceFile is called. @@ -105274,8 +106537,7 @@ var ts; var modulesWithElidedImports = new ts.Map(); // Track source files that are source files found by searching under node_modules, as these shouldn't be compiled. var sourceFilesFoundSearchingNodeModules = new ts.Map(); - var tracingData = ["program" /* Program */, "createProgram"]; - ts.tracing.begin.apply(ts.tracing, tracingData); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "createProgram", { configFilePath: options.configFilePath, rootDir: options.rootDir }, /*separateBeginAndEnd*/ true); ts.performance.mark("beforeProgram"); var host = createProgramOptions.host || createCompilerHost(options); var configParsingHost = parseConfigHostFromCompilerHostLike(host); @@ -105342,7 +106604,7 @@ var ts; var mapFromToProjectReferenceRedirectSource; var useSourceOfProjectReferenceRedirect = !!((_a = host.useSourceOfProjectReferenceRedirect) === null || _a === void 0 ? void 0 : _a.call(host)) && !options.disableSourceOfProjectReferenceRedirect; - var _c = updateHostForUseSourceOfProjectReferenceRedirect({ + var _d = updateHostForUseSourceOfProjectReferenceRedirect({ compilerHost: host, getSymlinkCache: getSymlinkCache, useSourceOfProjectReferenceRedirect: useSourceOfProjectReferenceRedirect, @@ -105350,16 +106612,16 @@ var ts; getResolvedProjectReferences: getResolvedProjectReferences, getSourceOfProjectReferenceRedirect: getSourceOfProjectReferenceRedirect, forEachResolvedProjectReference: forEachResolvedProjectReference - }), onProgramCreateComplete = _c.onProgramCreateComplete, fileExists = _c.fileExists, directoryExists = _c.directoryExists; - ts.tracing.push("program" /* Program */, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram }); + }), onProgramCreateComplete = _d.onProgramCreateComplete, fileExists = _d.fileExists, directoryExists = _d.directoryExists; + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram }); var shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options); - ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); // We set `structuralIsReused` to `undefined` because `tryReuseStructureFromOldProgram` calls `tryReuseStructureFromOldProgram` which checks // `structuralIsReused`, which would be a TDZ violation if it was not set in advance to `undefined`. var structureIsReused; - ts.tracing.push("program" /* Program */, "tryReuseStructureFromOldProgram", {}); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "tryReuseStructureFromOldProgram", {}); structureIsReused = tryReuseStructureFromOldProgram(); // eslint-disable-line prefer-const - ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); if (structureIsReused !== 2 /* Completely */) { processingDefaultLibFiles = []; processingOtherFiles = []; @@ -105368,50 +106630,50 @@ var ts; resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile); } if (rootNames.length) { - for (var _i = 0, resolvedProjectReferences_1 = resolvedProjectReferences; _i < resolvedProjectReferences_1.length; _i++) { - var parsedRef = resolvedProjectReferences_1[_i]; + resolvedProjectReferences === null || resolvedProjectReferences === void 0 ? void 0 : resolvedProjectReferences.forEach(function (parsedRef, index) { if (!parsedRef) - continue; + return; var out = ts.outFile(parsedRef.commandLine.options); if (useSourceOfProjectReferenceRedirect) { if (out || ts.getEmitModuleKind(parsedRef.commandLine.options) === ts.ModuleKind.None) { - for (var _d = 0, _e = parsedRef.commandLine.fileNames; _d < _e.length; _d++) { - var fileName = _e[_d]; - processSourceFile(fileName, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined); + for (var _i = 0, _a = parsedRef.commandLine.fileNames; _i < _a.length; _i++) { + var fileName = _a[_i]; + processProjectReferenceFile(fileName, { kind: ts.FileIncludeKind.SourceFromProjectReference, index: index }); } } } else { if (out) { - processSourceFile(ts.changeExtension(out, ".d.ts"), /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined); + processProjectReferenceFile(ts.changeExtension(out, ".d.ts"), { kind: ts.FileIncludeKind.OutputFromProjectReference, index: index }); } else if (ts.getEmitModuleKind(parsedRef.commandLine.options) === ts.ModuleKind.None) { - for (var _f = 0, _g = parsedRef.commandLine.fileNames; _f < _g.length; _f++) { - var fileName = _g[_f]; + var getCommonSourceDirectory_2 = ts.memoize(function () { return ts.getCommonSourceDirectoryOfConfig(parsedRef.commandLine, !host.useCaseSensitiveFileNames()); }); + for (var _b = 0, _c = parsedRef.commandLine.fileNames; _b < _c.length; _b++) { + var fileName = _c[_b]; if (!ts.fileExtensionIs(fileName, ".d.ts" /* Dts */) && !ts.fileExtensionIs(fileName, ".json" /* Json */)) { - processSourceFile(ts.getOutputDeclarationFileName(fileName, parsedRef.commandLine, !host.useCaseSensitiveFileNames()), /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined); + processProjectReferenceFile(ts.getOutputDeclarationFileName(fileName, parsedRef.commandLine, !host.useCaseSensitiveFileNames(), getCommonSourceDirectory_2), { kind: ts.FileIncludeKind.OutputFromProjectReference, index: index }); } } } } - } + }); } } - ts.tracing.push("program" /* Program */, "processRootFiles", { count: rootNames.length }); - ts.forEach(rootNames, function (name) { return processRootFile(name, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false); }); - ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processRootFiles", { count: rootNames.length }); + ts.forEach(rootNames, function (name, index) { return processRootFile(name, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, { kind: ts.FileIncludeKind.RootFile, index: index }); }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); // load type declarations specified via 'types' argument or implicitly from types/ and node_modules/@types folders var typeReferences = rootNames.length ? ts.getAutomaticTypeDirectiveNames(options, host) : ts.emptyArray; if (typeReferences.length) { - ts.tracing.push("program" /* Program */, "processTypeReferences", { count: typeReferences.length }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferences", { count: typeReferences.length }); // This containingFilename needs to match with the one used in managed-side var containingDirectory = options.configFilePath ? ts.getDirectoryPath(options.configFilePath) : host.getCurrentDirectory(); var containingFilename = ts.combinePaths(containingDirectory, ts.inferredTypesContainingFile); var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename); for (var i = 0; i < typeReferences.length; i++) { - processTypeReferenceDirective(typeReferences[i], resolutions[i]); + processTypeReferenceDirective(typeReferences[i], resolutions[i], { kind: ts.FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: typeReferences[i], packageId: (_b = resolutions[i]) === null || _b === void 0 ? void 0 : _b.packageId }); } - ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); } // Do not process the default library if: // - The '--noLib' flag is used. @@ -105422,11 +106684,11 @@ var ts; // otherwise, using options specified in '--lib' instead of '--target' default library file var defaultLibraryFileName = getDefaultLibraryFileName(); if (!options.lib && defaultLibraryFileName) { - processRootFile(defaultLibraryFileName, /*isDefaultLib*/ true, /*ignoreNoDefaultLib*/ false); + processRootFile(defaultLibraryFileName, /*isDefaultLib*/ true, /*ignoreNoDefaultLib*/ false, { kind: ts.FileIncludeKind.LibFile }); } else { - ts.forEach(options.lib, function (libFileName) { - processRootFile(ts.combinePaths(defaultLibraryPath, libFileName), /*isDefaultLib*/ true, /*ignoreNoDefaultLib*/ false); + ts.forEach(options.lib, function (libFileName, index) { + processRootFile(ts.combinePaths(defaultLibraryPath, libFileName), /*isDefaultLib*/ true, /*ignoreNoDefaultLib*/ false, { kind: ts.FileIncludeKind.LibFile, index: index }); }); } } @@ -105443,11 +106705,11 @@ var ts; // not part of the new program. if (oldProgram && host.onReleaseOldSourceFile) { var oldSourceFiles = oldProgram.getSourceFiles(); - for (var _h = 0, oldSourceFiles_1 = oldSourceFiles; _h < oldSourceFiles_1.length; _h++) { - var oldSourceFile = oldSourceFiles_1[_h]; + for (var _i = 0, oldSourceFiles_1 = oldSourceFiles; _i < oldSourceFiles_1.length; _i++) { + var oldSourceFile = oldSourceFiles_1[_i]; var newFile = getSourceFileByPath(oldSourceFile.resolvedPath); if (shouldCreateNewSourceFile || !newFile || - // old file wasnt redirect but new file is + // old file wasn't redirect but new file is (oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path)) { host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path)); } @@ -105466,7 +106728,6 @@ var ts; getSourceFileByPath: getSourceFileByPath, getSourceFiles: function () { return files; }, getMissingFilePaths: function () { return missingFilePaths; }, - getRefFileMap: function () { return refFileMap; }, getFilesByNameMap: function () { return filesByName; }, getCompilerOptions: function () { return options; }, getSyntacticDiagnostics: getSyntacticDiagnostics, @@ -105514,27 +106775,40 @@ var ts; fileExists: fileExists, directoryExists: directoryExists, getSymlinkCache: getSymlinkCache, - realpath: (_b = host.realpath) === null || _b === void 0 ? void 0 : _b.bind(host), + realpath: (_c = host.realpath) === null || _c === void 0 ? void 0 : _c.bind(host), useCaseSensitiveFileNames: function () { return host.useCaseSensitiveFileNames(); }, + getFileIncludeReasons: function () { return fileReasons; }, structureIsReused: structureIsReused, }; onProgramCreateComplete(); + // Add file processingDiagnostics + fileProcessingDiagnostics === null || fileProcessingDiagnostics === void 0 ? void 0 : fileProcessingDiagnostics.forEach(function (diagnostic) { + switch (diagnostic.kind) { + case 1 /* FilePreprocessingFileExplainingDiagnostic */: + return programDiagnostics.add(createDiagnosticExplainingFile(diagnostic.file && getSourceFileByPath(diagnostic.file), diagnostic.fileProcessingReason, diagnostic.diagnostic, diagnostic.args || ts.emptyArray)); + case 0 /* FilePreprocessingReferencedDiagnostic */: + var _a = getReferencedFileLocation(getSourceFileByPath, diagnostic.reason), file = _a.file, pos = _a.pos, end = _a.end; + return programDiagnostics.add(ts.createFileDiagnostic.apply(void 0, __spreadArray([file, ts.Debug.checkDefined(pos), ts.Debug.checkDefined(end) - pos, diagnostic.diagnostic], diagnostic.args || ts.emptyArray))); + default: + ts.Debug.assertNever(diagnostic); + } + }); verifyCompilerOptions(); ts.performance.mark("afterProgram"); ts.performance.measure("Program", "beforeProgram", "afterProgram"); - ts.tracing.end.apply(ts.tracing, tracingData); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); return program; function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) { if (!moduleNames.length) return ts.emptyArray; var containingFileName = ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory); var redirectedReference = getRedirectReferenceForResolution(containingFile); - ts.tracing.push("program" /* Program */, "resolveModuleNamesWorker", { containingFileName: containingFileName }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "resolveModuleNamesWorker", { containingFileName: containingFileName }); ts.performance.mark("beforeResolveModule"); var result = actualResolveModuleNamesWorker(moduleNames, containingFileName, reusedNames, redirectedReference); ts.performance.mark("afterResolveModule"); ts.performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule"); - ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); return result; } function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile) { @@ -105542,12 +106816,12 @@ var ts; return []; var containingFileName = !ts.isString(containingFile) ? ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile; var redirectedReference = !ts.isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : undefined; - ts.tracing.push("program" /* Program */, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName: containingFileName }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName: containingFileName }); ts.performance.mark("beforeResolveTypeReference"); var result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference); ts.performance.mark("afterResolveTypeReference"); ts.performance.measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference"); - ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); return result; } function getRedirectReferenceForResolution(file) { @@ -105606,25 +106880,8 @@ var ts; } function getCommonSourceDirectory() { if (commonSourceDirectory === undefined) { - var emittedFiles = ts.filter(files, function (file) { return ts.sourceFileMayBeEmitted(file, program); }); - if (options.rootDir && checkSourceFilesBelongToPath(emittedFiles, options.rootDir)) { - // If a rootDir is specified use it as the commonSourceDirectory - commonSourceDirectory = ts.getNormalizedAbsolutePath(options.rootDir, currentDirectory); - } - else if (options.composite && options.configFilePath) { - // Project compilations never infer their root from the input source paths - commonSourceDirectory = ts.getDirectoryPath(ts.normalizeSlashes(options.configFilePath)); - checkSourceFilesBelongToPath(emittedFiles, commonSourceDirectory); - } - else { - commonSourceDirectory = computeCommonSourceDirectory(emittedFiles); - } - if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== ts.directorySeparator) { - // Make sure directory path ends with directory separator so this string can directly - // used to replace with "" to get the relative path of the source file and the relative path doesn't - // start with / making it rooted path - commonSourceDirectory += ts.directorySeparator; - } + var emittedFiles_1 = ts.filter(files, function (file) { return ts.sourceFileMayBeEmitted(file, program); }); + commonSourceDirectory = ts.getCommonSourceDirectory(options, function () { return ts.mapDefined(emittedFiles_1, function (file) { return file.isDeclarationFile ? undefined : file.fileName; }); }, currentDirectory, getCanonicalFileName, function (commonSourceDirectory) { return checkSourceFilesBelongToPath(emittedFiles_1, commonSourceDirectory); }); } return commonSourceDirectory; } @@ -105968,7 +107225,6 @@ var ts; return 1 /* SafeModules */; } missingFilePaths = oldProgram.getMissingFilePaths(); - refFileMap = oldProgram.getRefFileMap(); // update fileName -> file mapping ts.Debug.assert(newSourceFiles.length === oldProgram.getSourceFiles().length); for (var _g = 0, newSourceFiles_1 = newSourceFiles; _g < newSourceFiles_1.length; _g++) { @@ -105991,11 +107247,8 @@ var ts; filesByName.set(path, filesByName.get(oldFile.path)); }); files = newSourceFiles; + fileReasons = oldProgram.getFileIncludeReasons(); fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics(); - for (var _h = 0, modifiedSourceFiles_2 = modifiedSourceFiles; _h < modifiedSourceFiles_2.length; _h++) { - var modifiedFile = modifiedSourceFiles_2[_h]; - fileProcessingDiagnostics.reattachFileDiagnostics(modifiedFile.newFile); - } resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives(); sourceFileToPackageName = oldProgram.sourceFileToPackageName; redirectTargetsMap = oldProgram.redirectTargetsMap; @@ -106035,12 +107288,12 @@ var ts; getProgramBuildInfo: function () { return program.getProgramBuildInfo && program.getProgramBuildInfo(); }, getSourceFileFromReference: function (file, ref) { return program.getSourceFileFromReference(file, ref); }, redirectTargetsMap: redirectTargetsMap, + getFileIncludeReasons: program.getFileIncludeReasons, }; } function emitBuildInfo(writeFileCallback) { ts.Debug.assert(!ts.outFile(options)); - var tracingData = ["emit" /* Emit */, "emitBuildInfo"]; - ts.tracing.begin.apply(ts.tracing, tracingData); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "emitBuildInfo", {}, /*separateBeginAndEnd*/ true); ts.performance.mark("beforeEmit"); var emitResult = ts.emitFiles(ts.notImplementedResolver, getEmitHost(writeFileCallback), /*targetSourceFile*/ undefined, @@ -106049,7 +107302,7 @@ var ts; /*onlyBuildInfo*/ true); ts.performance.mark("afterEmit"); ts.performance.measure("Emit", "beforeEmit", "afterEmit"); - ts.tracing.end.apply(ts.tracing, tracingData); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); return emitResult; } function getResolvedProjectReferences() { @@ -106095,10 +107348,9 @@ var ts; return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = ts.createTypeChecker(program, /*produceDiagnostics:*/ false)); } function emit(sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers, forceDtsEmit) { - var tracingData = ["emit" /* Emit */, "emit", { path: sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.path }]; - ts.tracing.begin.apply(ts.tracing, tracingData); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "emit", { path: sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.path }, /*separateBeginAndEnd*/ true); var result = runWithCancellationToken(function () { return emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers, forceDtsEmit); }); - ts.tracing.end.apply(ts.tracing, tracingData); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); return result; } function isEmitBlocked(emitFileName) { @@ -106152,30 +107404,22 @@ var ts; function getCachedSemanticDiagnostics(sourceFile) { var _a; return sourceFile - ? (_a = cachedBindAndCheckDiagnosticsForFile.perFile) === null || _a === void 0 ? void 0 : _a.get(sourceFile.path) : cachedBindAndCheckDiagnosticsForFile.allDiagnostics; + ? (_a = cachedBindAndCheckDiagnosticsForFile.perFile) === null || _a === void 0 ? void 0 : _a.get(sourceFile.path) + : cachedBindAndCheckDiagnosticsForFile.allDiagnostics; } function getBindAndCheckDiagnostics(sourceFile, cancellationToken) { return getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken); } function getProgramDiagnostics(sourceFile) { + var _a; if (ts.skipTypeChecking(sourceFile, options, program)) { return ts.emptyArray; } - var fileProcessingDiagnosticsInFile = fileProcessingDiagnostics.getDiagnostics(sourceFile.fileName); var programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName); - return getMergedProgramDiagnostics(sourceFile, fileProcessingDiagnosticsInFile, programDiagnosticsInFile); - } - function getMergedProgramDiagnostics(sourceFile) { - var _a; - var allDiagnostics = []; - for (var _i = 1; _i < arguments.length; _i++) { - allDiagnostics[_i - 1] = arguments[_i]; - } - var flatDiagnostics = ts.flatten(allDiagnostics); if (!((_a = sourceFile.commentDirectives) === null || _a === void 0 ? void 0 : _a.length)) { - return flatDiagnostics; + return programDiagnosticsInFile; } - return getDiagnosticsWithPrecedingDirectives(sourceFile, sourceFile.commentDirectives, flatDiagnostics).diagnostics; + return getDiagnosticsWithPrecedingDirectives(sourceFile, sourceFile.commentDirectives, programDiagnosticsInFile).diagnostics; } function getDeclarationDiagnostics(sourceFile, cancellationToken) { var options = program.getCompilerOptions(); @@ -106497,7 +107741,8 @@ var ts; function getAndCacheDiagnostics(sourceFile, cancellationToken, cache, getDiagnostics) { var _a; var cachedResult = sourceFile - ? (_a = cache.perFile) === null || _a === void 0 ? void 0 : _a.get(sourceFile.path) : cache.allDiagnostics; + ? (_a = cache.perFile) === null || _a === void 0 ? void 0 : _a.get(sourceFile.path) + : cache.allDiagnostics; if (cachedResult) { return cachedResult; } @@ -106514,7 +107759,7 @@ var ts; return sourceFile.isDeclarationFile ? [] : getDeclarationDiagnosticsWorker(sourceFile, cancellationToken); } function getOptionsDiagnostics() { - return ts.sortAndDeduplicateDiagnostics(ts.concatenate(fileProcessingDiagnostics.getGlobalDiagnostics(), ts.concatenate(programDiagnostics.getGlobalDiagnostics(), getOptionsDiagnosticsOfConfigFile()))); + return ts.sortAndDeduplicateDiagnostics(ts.concatenate(programDiagnostics.getGlobalDiagnostics(), getOptionsDiagnosticsOfConfigFile())); } function getOptionsDiagnosticsOfConfigFile() { if (!options.configFile) { @@ -106532,8 +107777,8 @@ var ts; function getConfigFileParsingDiagnostics() { return configFileParsingDiagnostics || ts.emptyArray; } - function processRootFile(fileName, isDefaultLib, ignoreNoDefaultLib) { - processSourceFile(ts.normalizePath(fileName), isDefaultLib, ignoreNoDefaultLib, /*packageId*/ undefined); + function processRootFile(fileName, isDefaultLib, ignoreNoDefaultLib, reason) { + processSourceFile(ts.normalizePath(fileName), isDefaultLib, ignoreNoDefaultLib, /*packageId*/ undefined, reason); } function fileReferenceIsEqualTo(a, b) { return a.fileName === b.fileName; @@ -106674,9 +107919,9 @@ var ts; } /** This should have similar behavior to 'processSourceFile' without diagnostics or mutation. */ function getSourceFileFromReference(referencingFile, ref) { - return getSourceFileFromReferenceWorker(resolveTripleslashReference(ref.fileName, referencingFile.fileName), function (fileName) { return filesByName.get(toPath(fileName)) || undefined; }); + return getSourceFileFromReferenceWorker(resolveTripleslashReference(ref.fileName, referencingFile.fileName), getSourceFile); } - function getSourceFileFromReferenceWorker(fileName, getSourceFile, fail, refFile) { + function getSourceFileFromReferenceWorker(fileName, getSourceFile, fail, reason) { if (ts.hasExtension(fileName)) { var canonicalFileName_1 = host.getCanonicalFileName(fileName); if (!options.allowNonTsExtensions && !ts.forEach(supportedExtensionsWithJsonIfResolveJsonModule, function (extension) { return ts.fileExtensionIs(canonicalFileName_1, extension); })) { @@ -106701,7 +107946,7 @@ var ts; fail(ts.Diagnostics.File_0_not_found, fileName); } } - else if (refFile && canonicalFileName_1 === host.getCanonicalFileName(refFile.fileName)) { + else if (isReferencedFile(reason) && canonicalFileName_1 === host.getCanonicalFileName(getSourceFileByPath(reason.file).fileName)) { fail(ts.Diagnostics.A_file_cannot_have_a_reference_to_itself); } } @@ -106722,22 +107967,27 @@ var ts; } } /** This has side effects through `findSourceFile`. */ - function processSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, packageId, refFile) { - getSourceFileFromReferenceWorker(fileName, function (fileName) { return findSourceFile(fileName, toPath(fileName), isDefaultLib, ignoreNoDefaultLib, refFile, packageId); }, // TODO: GH#18217 + function processSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, packageId, reason) { + getSourceFileFromReferenceWorker(fileName, function (fileName) { return findSourceFile(fileName, toPath(fileName), isDefaultLib, ignoreNoDefaultLib, reason, packageId); }, // TODO: GH#18217 function (diagnostic) { var args = []; for (var _i = 1; _i < arguments.length; _i++) { args[_i - 1] = arguments[_i]; } - return fileProcessingDiagnostics.add(createRefFileDiagnostic.apply(void 0, __spreadArrays([refFile, diagnostic], args))); - }, refFile && refFile.file); + return addFilePreprocessingFileExplainingDiagnostic(/*file*/ undefined, reason, diagnostic, args); + }, reason); + } + function processProjectReferenceFile(fileName, reason) { + return processSourceFile(fileName, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined, reason); } - function reportFileNamesDifferOnlyInCasingError(fileName, existingFile, refFile) { - var refs = !refFile ? refFileMap && refFileMap.get(existingFile.path) : undefined; - var refToReportErrorOn = refs && ts.find(refs, function (ref) { return ref.referencedFileName === existingFile.fileName; }); - fileProcessingDiagnostics.add(refToReportErrorOn ? - createFileDiagnosticAtReference(refToReportErrorOn, ts.Diagnostics.Already_included_file_name_0_differs_from_file_name_1_only_in_casing, existingFile.fileName, fileName) : - createRefFileDiagnostic(refFile, ts.Diagnostics.File_name_0_differs_from_already_included_file_name_1_only_in_casing, fileName, existingFile.fileName)); + function reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason) { + var hasExistingReasonToReportErrorOn = !isReferencedFile(reason) && ts.some(fileReasons.get(existingFile.path), isReferencedFile); + if (hasExistingReasonToReportErrorOn) { + addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, ts.Diagnostics.Already_included_file_name_0_differs_from_file_name_1_only_in_casing, [existingFile.fileName, fileName]); + } + else { + addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, ts.Diagnostics.File_name_0_differs_from_already_included_file_name_1_only_in_casing, [fileName, existingFile.fileName]); + } } function createRedirectSourceFile(redirectTarget, unredirected, fileName, path, resolvedPath, originalFileName) { var redirect = Object.create(redirectTarget); @@ -106760,17 +108010,17 @@ var ts; return redirect; } // Get source file from normalized fileName - function findSourceFile(fileName, path, isDefaultLib, ignoreNoDefaultLib, refFile, packageId) { - ts.tracing.push("program" /* Program */, "findSourceFile", { + function findSourceFile(fileName, path, isDefaultLib, ignoreNoDefaultLib, reason, packageId) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "findSourceFile", { fileName: fileName, isDefaultLib: isDefaultLib || undefined, - refKind: refFile ? ts.RefFileKind[refFile.kind] : undefined, + fileIncludeKind: ts.FileIncludeKind[reason.kind], }); - var result = findSourceFileWorker(fileName, path, isDefaultLib, ignoreNoDefaultLib, refFile, packageId); - ts.tracing.pop(); + var result = findSourceFileWorker(fileName, path, isDefaultLib, ignoreNoDefaultLib, reason, packageId); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); return result; } - function findSourceFileWorker(fileName, path, isDefaultLib, ignoreNoDefaultLib, refFile, packageId) { + function findSourceFileWorker(fileName, path, isDefaultLib, ignoreNoDefaultLib, reason, packageId) { if (useSourceOfProjectReferenceRedirect) { var source = getSourceOfProjectReferenceRedirect(fileName); // If preserveSymlinks is true, module resolution wont jump the symlink @@ -106788,7 +108038,7 @@ var ts; } if (source) { var file_1 = ts.isString(source) ? - findSourceFile(source, toPath(source), isDefaultLib, ignoreNoDefaultLib, refFile, packageId) : + findSourceFile(source, toPath(source), isDefaultLib, ignoreNoDefaultLib, reason, packageId) : undefined; if (file_1) addFileToFilesByName(file_1, path, /*redirectedPath*/ undefined); @@ -106798,7 +108048,7 @@ var ts; var originalFileName = fileName; if (filesByName.has(path)) { var file_2 = filesByName.get(path); - addFileToRefFileMap(fileName, file_2 || undefined, refFile); + addFileIncludeReason(file_2 || undefined, reason); // try to check if we've already seen this file but with a different casing in path // NOTE: this only makes sense for case-insensitive file systems, and only on files which are not redirected if (file_2 && options.forceConsistentCasingInFileNames) { @@ -106811,7 +108061,7 @@ var ts; var checkedAbsolutePath = ts.getNormalizedAbsolutePathWithoutRoot(checkedName, currentDirectory); var inputAbsolutePath = ts.getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory); if (checkedAbsolutePath !== inputAbsolutePath) { - reportFileNamesDifferOnlyInCasingError(fileName, file_2, refFile); + reportFileNamesDifferOnlyInCasingError(fileName, file_2, reason); } } // If the file was previously found via a node_modules search, but is now being processed as a root file, @@ -106838,7 +108088,7 @@ var ts; return file_2 || undefined; } var redirectedPath; - if (refFile && !useSourceOfProjectReferenceRedirect) { + if (isReferencedFile(reason) && !useSourceOfProjectReferenceRedirect) { var redirectProject = getProjectReferenceRedirectProject(fileName); if (redirectProject) { if (ts.outFile(redirectProject.commandLine.options)) { @@ -106856,7 +108106,7 @@ var ts; } } // We haven't looked for this file, do so now and cache result - var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { return fileProcessingDiagnostics.add(createRefFileDiagnostic(refFile, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); }, shouldCreateNewSourceFile); + var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { return addFilePreprocessingFileExplainingDiagnostic(/*file*/ undefined, reason, ts.Diagnostics.Cannot_read_file_0_Colon_1, [fileName, hostErrorMessage]); }, shouldCreateNewSourceFile); if (packageId) { var packageIdKey = ts.packageIdToString(packageId); var fileFromPackageId = packageIdToSourceFile.get(packageIdKey); @@ -106866,6 +108116,7 @@ var ts; var dupFile = createRedirectSourceFile(fileFromPackageId, file, fileName, path, toPath(fileName), originalFileName); // TODO: GH#18217 redirectTargetsMap.add(fileFromPackageId.path, fileName); addFileToFilesByName(dupFile, path, redirectedPath); + addFileIncludeReason(dupFile, reason); sourceFileToPackageName.set(path, packageId.name); processingOtherFiles.push(dupFile); return dupFile; @@ -106883,13 +108134,13 @@ var ts; file.path = path; file.resolvedPath = toPath(fileName); file.originalFileName = originalFileName; - addFileToRefFileMap(fileName, file, refFile); + addFileIncludeReason(file, reason); if (host.useCaseSensitiveFileNames()) { var pathLowerCase = ts.toFileNameLowerCase(path); // for case-sensitive file systems check if we've already seen some file with similar filename ignoring case var existingFile = filesByNameIgnoreCase.get(pathLowerCase); if (existingFile) { - reportFileNamesDifferOnlyInCasingError(fileName, existingFile, refFile); + reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason); } else { filesByNameIgnoreCase.set(pathLowerCase, file); @@ -106914,15 +108165,9 @@ var ts; } return file; } - function addFileToRefFileMap(referencedFileName, file, refFile) { - if (refFile && file) { - (refFileMap || (refFileMap = ts.createMultiMap())).add(file.path, { - referencedFileName: referencedFileName, - kind: refFile.kind, - index: refFile.index, - file: refFile.file.path - }); - } + function addFileIncludeReason(file, reason) { + if (file) + fileReasons.add(file.path, reason); } function addFileToFilesByName(file, path, redirectedPath) { if (redirectedPath) { @@ -106986,9 +108231,10 @@ var ts; mapFromToProjectReferenceRedirectSource.set(toPath(outputDts), true); } else { + var getCommonSourceDirectory_3 = ts.memoize(function () { return ts.getCommonSourceDirectoryOfConfig(resolvedRef.commandLine, !host.useCaseSensitiveFileNames()); }); ts.forEach(resolvedRef.commandLine.fileNames, function (fileName) { if (!ts.fileExtensionIs(fileName, ".d.ts" /* Dts */) && !ts.fileExtensionIs(fileName, ".json" /* Json */)) { - var outputDts = ts.getOutputDeclarationFileName(fileName, resolvedRef.commandLine, host.useCaseSensitiveFileNames()); + var outputDts = ts.getOutputDeclarationFileName(fileName, resolvedRef.commandLine, !host.useCaseSensitiveFileNames(), getCommonSourceDirectory_3); mapFromToProjectReferenceRedirectSource.set(toPath(outputDts), fileName); } }); @@ -107008,16 +108254,9 @@ var ts; } function processReferencedFiles(file, isDefaultLib) { ts.forEach(file.referencedFiles, function (ref, index) { - var referencedFileName = resolveTripleslashReference(ref.fileName, file.fileName); - processSourceFile(referencedFileName, isDefaultLib, + processSourceFile(resolveTripleslashReference(ref.fileName, file.fileName), isDefaultLib, /*ignoreNoDefaultLib*/ false, - /*packageId*/ undefined, { - kind: ts.RefFileKind.ReferenceFile, - index: index, - file: file, - pos: ref.pos, - end: ref.end - }); + /*packageId*/ undefined, { kind: ts.FileIncludeKind.ReferenceFile, file: file.path, index: index, }); }); } function processTypeReferenceDirectives(file) { @@ -107027,27 +108266,21 @@ var ts; return; } var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeDirectives, file); - for (var i = 0; i < typeDirectives.length; i++) { - var ref = file.typeReferenceDirectives[i]; - var resolvedTypeReferenceDirective = resolutions[i]; + for (var index = 0; index < typeDirectives.length; index++) { + var ref = file.typeReferenceDirectives[index]; + var resolvedTypeReferenceDirective = resolutions[index]; // store resolved type directive on the file var fileName = ts.toFileNameLowerCase(ref.fileName); ts.setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective); - processTypeReferenceDirective(fileName, resolvedTypeReferenceDirective, { - kind: ts.RefFileKind.TypeReferenceDirective, - index: i, - file: file, - pos: ref.pos, - end: ref.end - }); + processTypeReferenceDirective(fileName, resolvedTypeReferenceDirective, { kind: ts.FileIncludeKind.TypeReferenceDirective, file: file.path, index: index, }); } } - function processTypeReferenceDirective(typeReferenceDirective, resolvedTypeReferenceDirective, refFile) { - ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolveModuleNamesReusingOldState, refKind: refFile === null || refFile === void 0 ? void 0 : refFile.kind, refPath: refFile === null || refFile === void 0 ? void 0 : refFile.file.path }); - processTypeReferenceDirectiveWorker(typeReferenceDirective, resolvedTypeReferenceDirective, refFile); - ts.tracing.pop(); + function processTypeReferenceDirective(typeReferenceDirective, resolvedTypeReferenceDirective, reason) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolveModuleNamesReusingOldState, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined }); + processTypeReferenceDirectiveWorker(typeReferenceDirective, resolvedTypeReferenceDirective, reason); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); } - function processTypeReferenceDirectiveWorker(typeReferenceDirective, resolvedTypeReferenceDirective, refFile) { + function processTypeReferenceDirectiveWorker(typeReferenceDirective, resolvedTypeReferenceDirective, reason) { // If we already found this library as a primary reference - nothing to do var previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective); if (previousResolution && previousResolution.primary) { @@ -107059,7 +108292,7 @@ var ts; currentNodeModulesDepth++; if (resolvedTypeReferenceDirective.primary) { // resolved from the primary path - processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, resolvedTypeReferenceDirective.packageId, refFile); // TODO: GH#18217 + processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, resolvedTypeReferenceDirective.packageId, reason); // TODO: GH#18217 } else { // If we already resolved to this file, it must have been a secondary reference. Check file contents @@ -107068,14 +108301,9 @@ var ts; // Don't bother reading the file again if it's the same file. if (resolvedTypeReferenceDirective.resolvedFileName !== previousResolution.resolvedFileName) { var otherFileText = host.readFile(resolvedTypeReferenceDirective.resolvedFileName); - var existingFile_1 = getSourceFile(previousResolution.resolvedFileName); - if (otherFileText !== existingFile_1.text) { - // Try looking up ref for original file - var refs = !refFile ? refFileMap && refFileMap.get(existingFile_1.path) : undefined; - var refToReportErrorOn = refs && ts.find(refs, function (ref) { return ref.referencedFileName === existingFile_1.fileName; }); - fileProcessingDiagnostics.add(refToReportErrorOn ? - createFileDiagnosticAtReference(refToReportErrorOn, ts.Diagnostics.Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict, typeReferenceDirective, resolvedTypeReferenceDirective.resolvedFileName, previousResolution.resolvedFileName) : - createRefFileDiagnostic(refFile, ts.Diagnostics.Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict, typeReferenceDirective, resolvedTypeReferenceDirective.resolvedFileName, previousResolution.resolvedFileName)); + var existingFile = getSourceFile(previousResolution.resolvedFileName); + if (otherFileText !== existingFile.text) { + addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, ts.Diagnostics.Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict, [typeReferenceDirective, resolvedTypeReferenceDirective.resolvedFileName, previousResolution.resolvedFileName]); } } // don't overwrite previous resolution result @@ -107083,47 +108311,40 @@ var ts; } else { // First resolution of this library - processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, resolvedTypeReferenceDirective.packageId, refFile); + processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, resolvedTypeReferenceDirective.packageId, reason); } } if (resolvedTypeReferenceDirective.isExternalLibraryImport) currentNodeModulesDepth--; } else { - fileProcessingDiagnostics.add(createRefFileDiagnostic(refFile, ts.Diagnostics.Cannot_find_type_definition_file_for_0, typeReferenceDirective)); + addFilePreprocessingFileExplainingDiagnostic(/*file*/ undefined, reason, ts.Diagnostics.Cannot_find_type_definition_file_for_0, [typeReferenceDirective]); } if (saveResolution) { resolvedTypeReferenceDirectives.set(typeReferenceDirective, resolvedTypeReferenceDirective); } } function processLibReferenceDirectives(file) { - ts.forEach(file.libReferenceDirectives, function (libReference) { + ts.forEach(file.libReferenceDirectives, function (libReference, index) { var libName = ts.toFileNameLowerCase(libReference.fileName); var libFileName = ts.libMap.get(libName); if (libFileName) { // we ignore any 'no-default-lib' reference set on this file. - processRootFile(ts.combinePaths(defaultLibraryPath, libFileName), /*isDefaultLib*/ true, /*ignoreNoDefaultLib*/ true); + processRootFile(ts.combinePaths(defaultLibraryPath, libFileName), /*isDefaultLib*/ true, /*ignoreNoDefaultLib*/ true, { kind: ts.FileIncludeKind.LibReferenceDirective, file: file.path, index: index, }); } else { var unqualifiedLibName = ts.removeSuffix(ts.removePrefix(libName, "lib."), ".d.ts"); var suggestion = ts.getSpellingSuggestion(unqualifiedLibName, ts.libs, ts.identity); - var message = suggestion ? ts.Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 : ts.Diagnostics.Cannot_find_lib_definition_for_0; - fileProcessingDiagnostics.add(ts.createFileDiagnostic(file, libReference.pos, libReference.end - libReference.pos, message, libName, suggestion)); + var diagnostic = suggestion ? ts.Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 : ts.Diagnostics.Cannot_find_lib_definition_for_0; + (fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({ + kind: 0 /* FilePreprocessingReferencedDiagnostic */, + reason: { kind: ts.FileIncludeKind.LibReferenceDirective, file: file.path, index: index, }, + diagnostic: diagnostic, + args: [libName, suggestion] + }); } }); } - function createRefFileDiagnostic(refFile, message) { - var args = []; - for (var _i = 2; _i < arguments.length; _i++) { - args[_i - 2] = arguments[_i]; - } - if (!refFile) { - return ts.createCompilerDiagnostic.apply(void 0, __spreadArrays([message], args)); - } - else { - return ts.createFileDiagnostic.apply(void 0, __spreadArrays([refFile.file, refFile.pos, refFile.end - refFile.pos, message], args)); - } - } function getCanonicalFileName(fileName) { return host.getCanonicalFileName(fileName); } @@ -107134,9 +108355,9 @@ var ts; var moduleNames = getModuleNames(file); var resolutions = resolveModuleNamesReusingOldState(moduleNames, file); ts.Debug.assert(resolutions.length === moduleNames.length); - for (var i = 0; i < moduleNames.length; i++) { - var resolution = resolutions[i]; - ts.setResolvedModule(file, moduleNames[i], resolution); + for (var index = 0; index < moduleNames.length; index++) { + var resolution = resolutions[index]; + ts.setResolvedModule(file, moduleNames[index], resolution); if (!resolution) { continue; } @@ -107158,25 +108379,18 @@ var ts; var shouldAddFile = resolvedFileName && !getResolutionDiagnostic(options, resolution) && !options.noResolve - && i < file.imports.length + && index < file.imports.length && !elideImport && !(isJsFile && !ts.getAllowJSCompilerOption(options)) - && (ts.isInJSFile(file.imports[i]) || !(file.imports[i].flags & 4194304 /* JSDoc */)); + && (ts.isInJSFile(file.imports[index]) || !(file.imports[index].flags & 4194304 /* JSDoc */)); if (elideImport) { modulesWithElidedImports.set(file.path, true); } else if (shouldAddFile) { var path = toPath(resolvedFileName); - var pos = ts.skipTrivia(file.text, file.imports[i].pos); findSourceFile(resolvedFileName, path, /*isDefaultLib*/ false, - /*ignoreNoDefaultLib*/ false, { - kind: ts.RefFileKind.Import, - index: i, - file: file, - pos: pos, - end: file.imports[i].end - }, resolution.packageId); + /*ignoreNoDefaultLib*/ false, { kind: ts.FileIncludeKind.Import, file: file.path, index: index, }, resolution.packageId); } if (isFromNodeModulesSearch) { currentNodeModulesDepth--; @@ -107188,22 +108402,15 @@ var ts; file.resolvedModules = undefined; } } - function computeCommonSourceDirectory(sourceFiles) { - var fileNames = ts.mapDefined(sourceFiles, function (file) { return file.isDeclarationFile ? undefined : file.fileName; }); - return computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, getCanonicalFileName); - } function checkSourceFilesBelongToPath(sourceFiles, rootDirectory) { var allFilesBelongToPath = true; var absoluteRootDirectoryPath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(rootDirectory, currentDirectory)); - var rootPaths; for (var _i = 0, sourceFiles_2 = sourceFiles; _i < sourceFiles_2.length; _i++) { var sourceFile = sourceFiles_2[_i]; if (!sourceFile.isDeclarationFile) { var absoluteSourceFilePath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory)); if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) { - if (!rootPaths) - rootPaths = new ts.Set(rootNames.map(toPath)); - addProgramDiagnosticAtRefPath(sourceFile, rootPaths, ts.Diagnostics.File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files, sourceFile.fileName, rootDirectory); + addProgramDiagnosticExplainingFile(sourceFile, ts.Diagnostics.File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files, [sourceFile.fileName, rootDirectory]); allFilesBelongToPath = false; } } @@ -107301,7 +108508,7 @@ var ts; var file = files_3[_i]; // Ignore file that is not emitted if (ts.sourceFileMayBeEmitted(file, program) && !rootPaths.has(file.path)) { - addProgramDiagnosticAtRefPath(file, rootPaths, ts.Diagnostics.File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_include_pattern, file.fileName, options.configFilePath || ""); + addProgramDiagnosticExplainingFile(file, ts.Diagnostics.File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_include_pattern, [file.fileName, options.configFilePath || ""]); } } } @@ -107377,6 +108584,9 @@ var ts; if (options.module === ts.ModuleKind.None && languageVersion < 2 /* ES2015 */) { createDiagnosticForOptionName(ts.Diagnostics.Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher, "isolatedModules", "target"); } + if (options.preserveConstEnums === false) { + createDiagnosticForOptionName(ts.Diagnostics.Option_preserveConstEnums_cannot_be_disabled_when_isolatedModules_is_enabled, "preserveConstEnums", "isolatedModules"); + } var firstNonExternalModuleSourceFile = ts.find(files, function (f) { return !ts.isExternalModule(f) && !ts.isSourceFileJS(f) && !f.isDeclarationFile && f.scriptKind !== 6 /* JSON */; }); if (firstNonExternalModuleSourceFile) { var span = ts.getErrorSpanForNode(firstNonExternalModuleSourceFile, firstNonExternalModuleSourceFile); @@ -107509,40 +108719,130 @@ var ts; } } } - function createFileDiagnosticAtReference(refPathToReportErrorOn, message) { - var _a, _b; - var args = []; - for (var _i = 2; _i < arguments.length; _i++) { - args[_i - 2] = arguments[_i]; + function createDiagnosticExplainingFile(file, fileProcessingReason, diagnostic, args) { + var _a; + var fileIncludeReasons; + var relatedInfo; + var locationReason = isReferencedFile(fileProcessingReason) ? fileProcessingReason : undefined; + if (file) + (_a = fileReasons.get(file.path)) === null || _a === void 0 ? void 0 : _a.forEach(processReason); + if (fileProcessingReason) + processReason(fileProcessingReason); + // If we have location and there is only one reason file is in which is the location, dont add details for file include + if (locationReason && (fileIncludeReasons === null || fileIncludeReasons === void 0 ? void 0 : fileIncludeReasons.length) === 1) + fileIncludeReasons = undefined; + var location = locationReason && getReferencedFileLocation(getSourceFileByPath, locationReason); + var fileIncludeReasonDetails = fileIncludeReasons && ts.chainDiagnosticMessages(fileIncludeReasons, ts.Diagnostics.The_file_is_in_the_program_because_Colon); + var redirectInfo = file && ts.explainIfFileIsRedirect(file); + var chain = ts.chainDiagnosticMessages.apply(void 0, __spreadArray([redirectInfo ? fileIncludeReasonDetails ? __spreadArray([fileIncludeReasonDetails], redirectInfo) : redirectInfo : fileIncludeReasonDetails, diagnostic], args || ts.emptyArray)); + return location && isReferenceFileLocation(location) ? + ts.createFileDiagnosticFromMessageChain(location.file, location.pos, location.end - location.pos, chain, relatedInfo) : + ts.createCompilerDiagnosticFromMessageChain(chain, relatedInfo); + function processReason(reason) { + (fileIncludeReasons || (fileIncludeReasons = [])).push(ts.fileIncludeReasonToDiagnostics(program, reason)); + if (!locationReason && isReferencedFile(reason)) { + // Report error at first reference file or file currently in processing and dont report in related information + locationReason = reason; + } + else if (locationReason !== reason) { + relatedInfo = ts.append(relatedInfo, fileIncludeReasonToRelatedInformation(reason)); + } + // Remove fileProcessingReason if its already included in fileReasons of the program + if (reason === fileProcessingReason) + fileProcessingReason = undefined; + } + } + function addFilePreprocessingFileExplainingDiagnostic(file, fileProcessingReason, diagnostic, args) { + (fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({ + kind: 1 /* FilePreprocessingFileExplainingDiagnostic */, + file: file && file.path, + fileProcessingReason: fileProcessingReason, + diagnostic: diagnostic, + args: args + }); + } + function addProgramDiagnosticExplainingFile(file, diagnostic, args) { + programDiagnostics.add(createDiagnosticExplainingFile(file, /*fileProcessingReason*/ undefined, diagnostic, args)); + } + function fileIncludeReasonToRelatedInformation(reason) { + if (isReferencedFile(reason)) { + var referenceLocation = getReferencedFileLocation(getSourceFileByPath, reason); + var message_2; + switch (reason.kind) { + case ts.FileIncludeKind.Import: + message_2 = ts.Diagnostics.File_is_included_via_import_here; + break; + case ts.FileIncludeKind.ReferenceFile: + message_2 = ts.Diagnostics.File_is_included_via_reference_here; + break; + case ts.FileIncludeKind.TypeReferenceDirective: + message_2 = ts.Diagnostics.File_is_included_via_type_library_reference_here; + break; + case ts.FileIncludeKind.LibReferenceDirective: + message_2 = ts.Diagnostics.File_is_included_via_library_reference_here; + break; + default: + ts.Debug.assertNever(reason); + } + return isReferenceFileLocation(referenceLocation) ? ts.createFileDiagnostic(referenceLocation.file, referenceLocation.pos, referenceLocation.end - referenceLocation.pos, message_2) : undefined; } - var refFile = ts.Debug.checkDefined(getSourceFileByPath(refPathToReportErrorOn.file)); - var kind = refPathToReportErrorOn.kind, index = refPathToReportErrorOn.index; - var pos, end; - switch (kind) { - case ts.RefFileKind.Import: - pos = ts.skipTrivia(refFile.text, refFile.imports[index].pos); - end = refFile.imports[index].end; + if (!options.configFile) + return undefined; + var configFileNode; + var message; + switch (reason.kind) { + case ts.FileIncludeKind.RootFile: + if (!options.configFile.configFileSpecs) + return undefined; + var fileName = ts.getNormalizedAbsolutePath(rootNames[reason.index], currentDirectory); + var matchedByFiles = ts.getMatchedFileSpec(program, fileName); + if (matchedByFiles) { + configFileNode = ts.getTsConfigPropArrayElementValue(options.configFile, "files", matchedByFiles); + message = ts.Diagnostics.File_is_matched_by_files_list_specified_here; + break; + } + var matchedByInclude = ts.getMatchedIncludeSpec(program, fileName); + // Could be additional files specified as roots + if (!matchedByInclude) + return undefined; + configFileNode = ts.getTsConfigPropArrayElementValue(options.configFile, "include", matchedByInclude); + message = ts.Diagnostics.File_is_matched_by_include_pattern_specified_here; break; - case ts.RefFileKind.ReferenceFile: - (_a = refFile.referencedFiles[index], pos = _a.pos, end = _a.end); + case ts.FileIncludeKind.SourceFromProjectReference: + case ts.FileIncludeKind.OutputFromProjectReference: + var referencedResolvedRef_1 = ts.Debug.checkDefined(resolvedProjectReferences === null || resolvedProjectReferences === void 0 ? void 0 : resolvedProjectReferences[reason.index]); + var referenceInfo = forEachProjectReference(projectReferences, resolvedProjectReferences, function (resolvedRef, parent, index) { + return resolvedRef === referencedResolvedRef_1 ? { sourceFile: (parent === null || parent === void 0 ? void 0 : parent.sourceFile) || options.configFile, index: index } : undefined; + }); + if (!referenceInfo) + return undefined; + var sourceFile = referenceInfo.sourceFile, index = referenceInfo.index; + var referencesSyntax = ts.firstDefined(ts.getTsConfigPropArray(sourceFile, "references"), function (property) { return ts.isArrayLiteralExpression(property.initializer) ? property.initializer : undefined; }); + return referencesSyntax && referencesSyntax.elements.length > index ? + ts.createDiagnosticForNodeInSourceFile(sourceFile, referencesSyntax.elements[index], reason.kind === ts.FileIncludeKind.OutputFromProjectReference ? + ts.Diagnostics.File_is_output_from_referenced_project_specified_here : + ts.Diagnostics.File_is_source_from_referenced_project_specified_here) : + undefined; + case ts.FileIncludeKind.AutomaticTypeDirectiveFile: + if (!options.types) + return undefined; + configFileNode = getOptionsSyntaxByArrayElementValue("types", reason.typeReference); + message = ts.Diagnostics.File_is_entry_point_of_type_library_specified_here; break; - case ts.RefFileKind.TypeReferenceDirective: - (_b = refFile.typeReferenceDirectives[index], pos = _b.pos, end = _b.end); + case ts.FileIncludeKind.LibFile: + if (reason.index !== undefined) { + configFileNode = getOptionsSyntaxByArrayElementValue("lib", options.lib[reason.index]); + message = ts.Diagnostics.File_is_library_specified_here; + break; + } + var target = ts.forEachEntry(ts.targetOptionDeclaration.type, function (value, key) { return value === options.target ? key : undefined; }); + configFileNode = target ? getOptionsSyntaxByValue("target", target) : undefined; + message = ts.Diagnostics.File_is_default_library_for_target_specified_here; break; default: - return ts.Debug.assertNever(kind); - } - return ts.createFileDiagnostic.apply(void 0, __spreadArrays([refFile, pos, end - pos, message], args)); - } - function addProgramDiagnosticAtRefPath(file, rootPaths, message) { - var args = []; - for (var _i = 3; _i < arguments.length; _i++) { - args[_i - 3] = arguments[_i]; + ts.Debug.assertNever(reason); } - var refPaths = refFileMap === null || refFileMap === void 0 ? void 0 : refFileMap.get(file.path); - var refPathToReportErrorOn = ts.forEach(refPaths, function (refPath) { return rootPaths.has(refPath.file) ? refPath : undefined; }) || - ts.elementAt(refPaths, 0); - programDiagnostics.add(refPathToReportErrorOn ? createFileDiagnosticAtReference.apply(void 0, __spreadArrays([refPathToReportErrorOn, message], args)) : ts.createCompilerDiagnostic.apply(void 0, __spreadArrays([message], args))); + return configFileNode && ts.createDiagnosticForNodeInSourceFile(options.configFile, configFileNode, message); } function verifyProjectReferences() { var buildInfoPath = !options.suppressOutputPathCheck ? ts.getTsBuildInfoEmitOutputFilePath(options) : undefined; @@ -107617,14 +108917,19 @@ var ts; } function getOptionsSyntaxByName(name) { var compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax(); - if (compilerOptionsObjectLiteralSyntax) { - return ts.getPropertyAssignment(compilerOptionsObjectLiteralSyntax, name); - } - return undefined; + return compilerOptionsObjectLiteralSyntax && ts.getPropertyAssignment(compilerOptionsObjectLiteralSyntax, name); } function getOptionPathsSyntax() { return getOptionsSyntaxByName("paths") || ts.emptyArray; } + function getOptionsSyntaxByValue(name, value) { + var syntaxByName = getOptionsSyntaxByName(name); + return syntaxByName && ts.firstDefined(syntaxByName, function (property) { return ts.isStringLiteral(property.initializer) && property.initializer.text === value ? property.initializer : undefined; }); + } + function getOptionsSyntaxByArrayElementValue(name, value) { + var compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax(); + return compilerOptionsObjectLiteralSyntax && ts.getPropertyArrayElementValue(compilerOptionsObjectLiteralSyntax, name, value); + } function createDiagnosticForOptionName(message, option1, option2, option3) { createDiagnosticForOption(/*onKey*/ true, option1, option2, message, option1, option2, option3); } @@ -107650,7 +108955,7 @@ var ts; } function getCompilerOptionsObjectLiteralSyntax() { if (_compilerOptionsObjectLiteralSyntax === undefined) { - _compilerOptionsObjectLiteralSyntax = null; // eslint-disable-line no-null/no-null + _compilerOptionsObjectLiteralSyntax = false; var jsonObjectLiteral = ts.getTsConfigObjectLiteralExpression(options.configFile); if (jsonObjectLiteral) { for (var _i = 0, _a = ts.getPropertyAssignment(jsonObjectLiteral, "compilerOptions"); _i < _a.length; _i++) { @@ -107662,7 +108967,7 @@ var ts; } } } - return _compilerOptionsObjectLiteralSyntax; + return _compilerOptionsObjectLiteralSyntax || undefined; } function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral, onKey, key1, key2, message, arg0, arg1, arg2) { var props = ts.getPropertyAssignment(objectLiteral, key1, key2); @@ -107811,7 +109116,7 @@ var ts; } function handleDirectoryCouldBeSymlink(directory) { var _a; - if (!host.getResolvedProjectReferences()) + if (!host.getResolvedProjectReferences() || ts.containsIgnoredPath(directory)) return; // Because we already watch node_modules, handle symlinks in there if (!originalRealpath || !ts.stringContains(directory, ts.nodeModulesPathPart)) @@ -107828,7 +109133,7 @@ var ts; symlinkCache.setSymlinkedDirectory(directoryPath, false); return; } - symlinkCache.setSymlinkedDirectory(directoryPath, { + symlinkCache.setSymlinkedDirectory(directory, { real: ts.ensureTrailingDirectorySeparator(real), realPath: realPath }); @@ -107883,7 +109188,7 @@ var ts; // get any preEmit diagnostics, not just the ones if (!options.noEmitOnError) return undefined; - var diagnostics = __spreadArrays(program.getOptionsDiagnostics(cancellationToken), program.getSyntacticDiagnostics(sourceFile, cancellationToken), program.getGlobalDiagnostics(cancellationToken), program.getSemanticDiagnostics(sourceFile, cancellationToken)); + var diagnostics = __spreadArray(__spreadArray(__spreadArray(__spreadArray([], program.getOptionsDiagnostics(cancellationToken)), program.getSyntacticDiagnostics(sourceFile, cancellationToken)), program.getGlobalDiagnostics(cancellationToken)), program.getSemanticDiagnostics(sourceFile, cancellationToken)); if (diagnostics.length === 0 && ts.getEmitDeclarations(program.getCompilerOptions())) { diagnostics = program.getDeclarationDiagnostics(/*sourceFile*/ undefined, cancellationToken); } @@ -107893,7 +109198,7 @@ var ts; if (!sourceFile && !ts.outFile(options)) { var emitResult = program.emitBuildInfo(writeFile, cancellationToken); if (emitResult.diagnostics) - diagnostics = __spreadArrays(diagnostics, emitResult.diagnostics); + diagnostics = __spreadArray(__spreadArray([], diagnostics), emitResult.diagnostics); emittedFiles = emitResult.emittedFiles; } return { diagnostics: diagnostics, sourceMaps: undefined, emittedFiles: emittedFiles, emitSkipped: true }; @@ -107992,6 +109297,24 @@ var ts; } return res; } + /* @internal */ + function getModuleNameStringLiteralAt(_a, index) { + var imports = _a.imports, moduleAugmentations = _a.moduleAugmentations; + if (index < imports.length) + return imports[index]; + var augIndex = imports.length; + for (var _i = 0, moduleAugmentations_2 = moduleAugmentations; _i < moduleAugmentations_2.length; _i++) { + var aug = moduleAugmentations_2[_i]; + if (aug.kind === 10 /* StringLiteral */) { + if (index === augIndex) + return aug; + augIndex++; + } + // Do nothing if it's an Identifier; we don't need to do module resolution for `declare global`. + } + ts.Debug.fail("should never ask for module name at index higher than possible module name"); + } + ts.getModuleNameStringLiteralAt = getModuleNameStringLiteralAt; })(ts || (ts = {})); /*@internal*/ var ts; @@ -108505,7 +109828,7 @@ var ts; var newReferences; // if not using old state, every file is changed if (!useOldState || - // File wasnt present in old state + // File wasn't present in old state !(oldInfo = oldState.fileInfos.get(sourceFilePath)) || // versions dont match oldInfo.version !== info.version || @@ -109539,6 +110862,7 @@ var ts; invalidateResolutionsOfFailedLookupLocations: invalidateResolutionsOfFailedLookupLocations, setFilesWithInvalidatedNonRelativeUnresolvedImports: setFilesWithInvalidatedNonRelativeUnresolvedImports, createHasInvalidatedResolution: createHasInvalidatedResolution, + isFileWithInvalidatedNonRelativeUnresolvedImports: isFileWithInvalidatedNonRelativeUnresolvedImports, updateTypeRootsWatch: updateTypeRootsWatch, closeTypeRootsWatch: closeTypeRootsWatch, clear: clear @@ -109657,7 +110981,7 @@ var ts; var resolvedModules = []; var compilerOptions = resolutionHost.getCompilationSettings(); var hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path); - // All the resolutions in this file are invalidated if this file wasnt resolved using same redirect + // All the resolutions in this file are invalidated if this file wasn't resolved using same redirect var program = resolutionHost.getCurrentProgram(); var oldRedirect = program && program.getResolvedProjectReferenceToRedirect(containingFile); var unmatchedRedirects = oldRedirect ? @@ -110136,7 +111460,8 @@ var ts; (function (RelativePreference) { RelativePreference[RelativePreference["Relative"] = 0] = "Relative"; RelativePreference[RelativePreference["NonRelative"] = 1] = "NonRelative"; - RelativePreference[RelativePreference["Auto"] = 2] = "Auto"; + RelativePreference[RelativePreference["Shortest"] = 2] = "Shortest"; + RelativePreference[RelativePreference["ExternalNonRelative"] = 3] = "ExternalNonRelative"; })(RelativePreference || (RelativePreference = {})); // See UserPreferences#importPathEnding var Ending; @@ -110148,7 +111473,10 @@ var ts; function getPreferences(_a, compilerOptions, importingSourceFile) { var importModuleSpecifierPreference = _a.importModuleSpecifierPreference, importModuleSpecifierEnding = _a.importModuleSpecifierEnding; return { - relativePreference: importModuleSpecifierPreference === "relative" ? 0 /* Relative */ : importModuleSpecifierPreference === "non-relative" ? 1 /* NonRelative */ : 2 /* Auto */, + relativePreference: importModuleSpecifierPreference === "relative" ? 0 /* Relative */ : + importModuleSpecifierPreference === "non-relative" ? 1 /* NonRelative */ : + importModuleSpecifierPreference === "project-relative" ? 3 /* ExternalNonRelative */ : + 2 /* Shortest */, ending: getEnding(), }; function getEnding() { @@ -110195,14 +111523,25 @@ var ts; getLocalModuleSpecifier(toFileName, info, compilerOptions, host, preferences); } /** Returns an import for each symlink and for the realpath. */ - function getModuleSpecifiers(moduleSymbol, compilerOptions, importingSourceFile, host, userPreferences) { - var ambient = tryGetModuleNameFromAmbientModule(moduleSymbol); + function getModuleSpecifiers(moduleSymbol, checker, compilerOptions, importingSourceFile, host, userPreferences) { + var ambient = tryGetModuleNameFromAmbientModule(moduleSymbol, checker); if (ambient) return [ambient]; var info = getInfo(importingSourceFile.path, host); var moduleSourceFile = ts.getSourceFileOfNode(moduleSymbol.valueDeclaration || ts.getNonAugmentationDeclaration(moduleSymbol)); var modulePaths = getAllModulePaths(importingSourceFile.path, moduleSourceFile.originalFileName, host); var preferences = getPreferences(userPreferences, compilerOptions, importingSourceFile); + var existingSpecifier = ts.forEach(modulePaths, function (modulePath) { return ts.forEach(host.getFileIncludeReasons().get(ts.toPath(modulePath.path, host.getCurrentDirectory(), info.getCanonicalFileName)), function (reason) { + if (reason.kind !== ts.FileIncludeKind.Import || reason.file !== importingSourceFile.path) + return undefined; + var specifier = ts.getModuleNameStringLiteralAt(importingSourceFile, reason.index).text; + // If the preference is for non relative and the module specifier is relative, ignore it + return preferences.relativePreference !== 1 /* NonRelative */ || !ts.pathIsRelative(specifier) ? + specifier : + undefined; + }); }); + if (existingSpecifier) + return [existingSpecifier]; var importedFileIsInNodeModules = ts.some(modulePaths, function (p) { return p.isInNodeModules; }); // Module specifier priority: // 1. "Bare package specifiers" (e.g. "@foo/bar") resulting from a path through node_modules to a package.json's "types" entry @@ -110249,12 +111588,12 @@ var ts; function getInfo(importingSourceFileName, host) { var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : true); var sourceDirectory = ts.getDirectoryPath(importingSourceFileName); - return { getCanonicalFileName: getCanonicalFileName, sourceDirectory: sourceDirectory }; + return { getCanonicalFileName: getCanonicalFileName, importingSourceFileName: importingSourceFileName, sourceDirectory: sourceDirectory }; } - function getLocalModuleSpecifier(moduleFileName, _a, compilerOptions, host, _b) { - var getCanonicalFileName = _a.getCanonicalFileName, sourceDirectory = _a.sourceDirectory; - var ending = _b.ending, relativePreference = _b.relativePreference; + function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, _a) { + var ending = _a.ending, relativePreference = _a.relativePreference; var baseUrl = compilerOptions.baseUrl, paths = compilerOptions.paths, rootDirs = compilerOptions.rootDirs; + var sourceDirectory = info.sourceDirectory, getCanonicalFileName = info.getCanonicalFileName; var relativePath = rootDirs && tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) || removeExtensionAndIndexPostFix(ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(sourceDirectory, moduleFileName, getCanonicalFileName)), ending, compilerOptions); if (!baseUrl && !paths || relativePreference === 0 /* Relative */) { @@ -110274,7 +111613,39 @@ var ts; if (relativePreference === 1 /* NonRelative */) { return nonRelative; } - if (relativePreference !== 2 /* Auto */) + if (relativePreference === 3 /* ExternalNonRelative */) { + var projectDirectory = host.getCurrentDirectory(); + var modulePath = ts.toPath(moduleFileName, projectDirectory, getCanonicalFileName); + var sourceIsInternal = ts.startsWith(sourceDirectory, projectDirectory); + var targetIsInternal = ts.startsWith(modulePath, projectDirectory); + if (sourceIsInternal && !targetIsInternal || !sourceIsInternal && targetIsInternal) { + // 1. The import path crosses the boundary of the tsconfig.json-containing directory. + // + // src/ + // tsconfig.json + // index.ts ------- + // lib/ | (path crosses tsconfig.json) + // imported.ts <--- + // + return nonRelative; + } + var nearestTargetPackageJson = getNearestAncestorDirectoryWithPackageJson(host, ts.getDirectoryPath(modulePath)); + var nearestSourcePackageJson = getNearestAncestorDirectoryWithPackageJson(host, sourceDirectory); + if (nearestSourcePackageJson !== nearestTargetPackageJson) { + // 2. The importing and imported files are part of different packages. + // + // packages/a/ + // package.json + // index.ts -------- + // packages/b/ | (path crosses package.json) + // package.json | + // component.ts <--- + // + return nonRelative; + } + return relativePath; + } + if (relativePreference !== 2 /* Shortest */) ts.Debug.assertNever(relativePreference); // Prefer a relative import over a baseUrl import if it has fewer components. return isPathRelativeToParent(nonRelative) || countPathComponents(relativePath) < countPathComponents(nonRelative) ? relativePath : nonRelative; @@ -110295,51 +111666,64 @@ var ts; return ts.pathIsRelative(text) ? ts.hasJSFileExtension(text) : undefined; }) || false; } - function numberOfDirectorySeparators(str) { - var match = str.match(/\//g); - return match ? match.length : 0; - } function comparePathsByRedirectAndNumberOfDirectorySeparators(a, b) { - return ts.compareBooleans(b.isRedirect, a.isRedirect) || ts.compareValues(numberOfDirectorySeparators(a.path), numberOfDirectorySeparators(b.path)); + return ts.compareBooleans(b.isRedirect, a.isRedirect) || ts.compareNumberOfDirectorySeparators(a.path, b.path); + } + function getNearestAncestorDirectoryWithPackageJson(host, fileName) { + if (host.getNearestAncestorDirectoryWithPackageJson) { + return host.getNearestAncestorDirectoryWithPackageJson(fileName); + } + return !!ts.forEachAncestorDirectory(fileName, function (directory) { + return host.fileExists(ts.combinePaths(directory, "package.json")) ? true : undefined; + }); } function forEachFileNameOfModule(importingFileName, importedFileName, host, preferSymlinks, cb) { var getCanonicalFileName = ts.hostGetCanonicalFileName(host); var cwd = host.getCurrentDirectory(); var referenceRedirect = host.isSourceOfProjectReferenceRedirect(importedFileName) ? host.getProjectReferenceRedirect(importedFileName) : undefined; - var redirects = host.redirectTargetsMap.get(ts.toPath(importedFileName, cwd, getCanonicalFileName)) || ts.emptyArray; - var importedFileNames = __spreadArrays((referenceRedirect ? [referenceRedirect] : ts.emptyArray), [importedFileName], redirects); + var importedPath = ts.toPath(importedFileName, cwd, getCanonicalFileName); + var redirects = host.redirectTargetsMap.get(importedPath) || ts.emptyArray; + var importedFileNames = __spreadArray(__spreadArray(__spreadArray([], (referenceRedirect ? [referenceRedirect] : ts.emptyArray)), [importedFileName]), redirects); var targets = importedFileNames.map(function (f) { return ts.getNormalizedAbsolutePath(f, cwd); }); + var shouldFilterIgnoredPaths = !ts.every(targets, ts.containsIgnoredPath); if (!preferSymlinks) { - var result_15 = ts.forEach(targets, function (p) { return cb(p, referenceRedirect === p); }); + // Symlinks inside ignored paths are already filtered out of the symlink cache, + // so we only need to remove them from the realpath filenames. + var result_15 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); }); if (result_15) return result_15; } var links = host.getSymlinkCache ? host.getSymlinkCache() : ts.discoverProbableSymlinks(host.getSourceFiles(), getCanonicalFileName, cwd); - var symlinkedDirectories = links.getSymlinkedDirectories(); - var useCaseSensitiveFileNames = !host.useCaseSensitiveFileNames || host.useCaseSensitiveFileNames(); - var result = symlinkedDirectories && ts.forEachEntry(symlinkedDirectories, function (resolved, path) { - if (resolved === false) - return undefined; - if (ts.startsWithDirectory(importingFileName, resolved.realPath, getCanonicalFileName)) { - return undefined; // Don't want to a package to globally import from itself + var symlinkedDirectories = links.getSymlinkedDirectoriesByRealpath(); + var fullImportedFileName = ts.getNormalizedAbsolutePath(importedFileName, cwd); + var result = symlinkedDirectories && ts.forEachAncestorDirectory(ts.getDirectoryPath(fullImportedFileName), function (realPathDirectory) { + var symlinkDirectories = symlinkedDirectories.get(ts.ensureTrailingDirectorySeparator(ts.toPath(realPathDirectory, cwd, getCanonicalFileName))); + if (!symlinkDirectories) + return undefined; // Continue to ancestor directory + // Don't want to a package to globally import from itself (importNameCodeFix_symlink_own_package.ts) + if (ts.startsWithDirectory(importingFileName, realPathDirectory, getCanonicalFileName)) { + return false; // Stop search, each ancestor directory will also hit this condition } return ts.forEach(targets, function (target) { - if (!ts.containsPath(resolved.real, target, !useCaseSensitiveFileNames)) { + if (!ts.startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) { return; } - var relative = ts.getRelativePathFromDirectory(resolved.real, target, getCanonicalFileName); - var option = ts.resolvePath(path, relative); - if (!host.fileExists || host.fileExists(option)) { + var relative = ts.getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName); + for (var _i = 0, symlinkDirectories_1 = symlinkDirectories; _i < symlinkDirectories_1.length; _i++) { + var symlinkDirectory = symlinkDirectories_1[_i]; + var option = ts.resolvePath(symlinkDirectory, relative); var result_16 = cb(option, target === referenceRedirect); + shouldFilterIgnoredPaths = true; // We found a non-ignored path in symlinks, so we can reject ignored-path realpaths if (result_16) return result_16; } }); }); - return result || - (preferSymlinks ? ts.forEach(targets, function (p) { return cb(p, p === referenceRedirect); }) : undefined); + return result || (preferSymlinks + ? ts.forEach(targets, function (p) { return shouldFilterIgnoredPaths && ts.containsIgnoredPath(p) ? undefined : cb(p, p === referenceRedirect); }) + : undefined); } moduleSpecifiers.forEachFileNameOfModule = forEachFileNameOfModule; /** @@ -110397,11 +111781,49 @@ var ts; } return sortedPaths; } - function tryGetModuleNameFromAmbientModule(moduleSymbol) { + function tryGetModuleNameFromAmbientModule(moduleSymbol, checker) { var decl = ts.find(moduleSymbol.declarations, function (d) { return ts.isNonGlobalAmbientModule(d) && (!ts.isExternalModuleAugmentation(d) || !ts.isExternalModuleNameRelative(ts.getTextOfIdentifierOrLiteral(d.name))); }); if (decl) { return decl.name.text; } + // the module could be a namespace, which is export through "export=" from an ambient module. + /** + * declare module "m" { + * namespace ns { + * class c {} + * } + * export = ns; + * } + */ + // `import {c} from "m";` is valid, in which case, `moduleSymbol` is "ns", but the module name should be "m" + var ambientModuleDeclareCandidates = ts.mapDefined(moduleSymbol.declarations, function (d) { + var _a, _b, _c, _d; + if (!ts.isModuleDeclaration(d)) + return; + var topNamespace = getTopNamespace(d); + if (!(((_a = topNamespace === null || topNamespace === void 0 ? void 0 : topNamespace.parent) === null || _a === void 0 ? void 0 : _a.parent) + && ts.isModuleBlock(topNamespace.parent) && ts.isAmbientModule(topNamespace.parent.parent) && ts.isSourceFile(topNamespace.parent.parent.parent))) + return; + var exportAssignment = (_d = (_c = (_b = topNamespace.parent.parent.symbol.exports) === null || _b === void 0 ? void 0 : _b.get("export=")) === null || _c === void 0 ? void 0 : _c.valueDeclaration) === null || _d === void 0 ? void 0 : _d.expression; + if (!exportAssignment) + return; + var exportSymbol = checker.getSymbolAtLocation(exportAssignment); + if (!exportSymbol) + return; + var originalExportSymbol = (exportSymbol === null || exportSymbol === void 0 ? void 0 : exportSymbol.flags) & 2097152 /* Alias */ ? checker.getAliasedSymbol(exportSymbol) : exportSymbol; + if (originalExportSymbol === d.symbol) + return topNamespace.parent.parent; + function getTopNamespace(namespaceDeclaration) { + while (namespaceDeclaration.flags & 4 /* NestedNamespace */) { + namespaceDeclaration = namespaceDeclaration.parent; + } + return namespaceDeclaration; + } + }); + var ambientModuleDeclare = ambientModuleDeclareCandidates[0]; + if (ambientModuleDeclare) { + return ambientModuleDeclare.name.text; + } } function tryGetModuleNameFromPaths(relativeToBaseUrlWithIndex, relativeToBaseUrl, paths) { for (var key in paths) { @@ -110745,18 +112167,176 @@ var ts; return "" + newLine + ts.flattenDiagnosticMessageText(d.messageText, newLine) + newLine + newLine; } ts.getErrorSummaryText = getErrorSummaryText; - function listFiles(program, writeFileName) { - if (program.getCompilerOptions().listFiles || program.getCompilerOptions().listFilesOnly) { + function isBuilderProgram(program) { + return !!program.getState; + } + ts.isBuilderProgram = isBuilderProgram; + function listFiles(program, write) { + var options = program.getCompilerOptions(); + if (options.explainFiles) { + explainFiles(isBuilderProgram(program) ? program.getProgram() : program, write); + } + else if (options.listFiles || options.listFilesOnly) { ts.forEach(program.getSourceFiles(), function (file) { - writeFileName(file.fileName); + write(file.fileName); }); } } ts.listFiles = listFiles; + function explainFiles(program, write) { + var _a, _b; + var reasons = program.getFileIncludeReasons(); + var getCanonicalFileName = ts.createGetCanonicalFileName(program.useCaseSensitiveFileNames()); + var relativeFileName = function (fileName) { return ts.convertToRelativePath(fileName, program.getCurrentDirectory(), getCanonicalFileName); }; + for (var _i = 0, _c = program.getSourceFiles(); _i < _c.length; _i++) { + var file = _c[_i]; + write("" + toFileName(file, relativeFileName)); + (_a = reasons.get(file.path)) === null || _a === void 0 ? void 0 : _a.forEach(function (reason) { return write(" " + fileIncludeReasonToDiagnostics(program, reason, relativeFileName).messageText); }); + (_b = explainIfFileIsRedirect(file, relativeFileName)) === null || _b === void 0 ? void 0 : _b.forEach(function (d) { return write(" " + d.messageText); }); + } + } + ts.explainFiles = explainFiles; + function explainIfFileIsRedirect(file, fileNameConvertor) { + var result; + if (file.path !== file.resolvedPath) { + (result || (result = [])).push(ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.File_is_output_of_project_reference_source_0, toFileName(file.originalFileName, fileNameConvertor))); + } + if (file.redirectInfo) { + (result || (result = [])).push(ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.File_redirects_to_file_0, toFileName(file.redirectInfo.redirectTarget, fileNameConvertor))); + } + return result; + } + ts.explainIfFileIsRedirect = explainIfFileIsRedirect; + function getMatchedFileSpec(program, fileName) { + var _a; + var configFile = program.getCompilerOptions().configFile; + if (!((_a = configFile === null || configFile === void 0 ? void 0 : configFile.configFileSpecs) === null || _a === void 0 ? void 0 : _a.validatedFilesSpec)) + return undefined; + var getCanonicalFileName = ts.createGetCanonicalFileName(program.useCaseSensitiveFileNames()); + var filePath = getCanonicalFileName(fileName); + var basePath = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(configFile.fileName, program.getCurrentDirectory())); + return ts.find(configFile.configFileSpecs.validatedFilesSpec, function (fileSpec) { return getCanonicalFileName(ts.getNormalizedAbsolutePath(fileSpec, basePath)) === filePath; }); + } + ts.getMatchedFileSpec = getMatchedFileSpec; + function getMatchedIncludeSpec(program, fileName) { + var _a, _b; + var configFile = program.getCompilerOptions().configFile; + if (!((_a = configFile === null || configFile === void 0 ? void 0 : configFile.configFileSpecs) === null || _a === void 0 ? void 0 : _a.validatedIncludeSpecs)) + return undefined; + var isJsonFile = ts.fileExtensionIs(fileName, ".json" /* Json */); + var basePath = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(configFile.fileName, program.getCurrentDirectory())); + var useCaseSensitiveFileNames = program.useCaseSensitiveFileNames(); + return ts.find((_b = configFile === null || configFile === void 0 ? void 0 : configFile.configFileSpecs) === null || _b === void 0 ? void 0 : _b.validatedIncludeSpecs, function (includeSpec) { + if (isJsonFile && !ts.endsWith(includeSpec, ".json" /* Json */)) + return false; + var pattern = ts.getPatternFromSpec(includeSpec, basePath, "files"); + return !!pattern && ts.getRegexFromPattern("(" + pattern + ")$", useCaseSensitiveFileNames).test(fileName); + }); + } + ts.getMatchedIncludeSpec = getMatchedIncludeSpec; + function fileIncludeReasonToDiagnostics(program, reason, fileNameConvertor) { + var _a, _b; + var options = program.getCompilerOptions(); + if (ts.isReferencedFile(reason)) { + var referenceLocation = ts.getReferencedFileLocation(function (path) { return program.getSourceFileByPath(path); }, reason); + var referenceText = ts.isReferenceFileLocation(referenceLocation) ? referenceLocation.file.text.substring(referenceLocation.pos, referenceLocation.end) : "\"" + referenceLocation.text + "\""; + var message = void 0; + ts.Debug.assert(ts.isReferenceFileLocation(referenceLocation) || reason.kind === ts.FileIncludeKind.Import, "Only synthetic references are imports"); + switch (reason.kind) { + case ts.FileIncludeKind.Import: + if (ts.isReferenceFileLocation(referenceLocation)) { + message = referenceLocation.packageId ? + ts.Diagnostics.Imported_via_0_from_file_1_with_packageId_2 : + ts.Diagnostics.Imported_via_0_from_file_1; + } + else if (referenceLocation.text === ts.externalHelpersModuleNameText) { + message = referenceLocation.packageId ? + ts.Diagnostics.Imported_via_0_from_file_1_with_packageId_2_to_import_importHelpers_as_specified_in_compilerOptions : + ts.Diagnostics.Imported_via_0_from_file_1_to_import_importHelpers_as_specified_in_compilerOptions; + } + else { + message = referenceLocation.packageId ? + ts.Diagnostics.Imported_via_0_from_file_1_with_packageId_2_to_import_jsx_and_jsxs_factory_functions : + ts.Diagnostics.Imported_via_0_from_file_1_to_import_jsx_and_jsxs_factory_functions; + } + break; + case ts.FileIncludeKind.ReferenceFile: + ts.Debug.assert(!referenceLocation.packageId); + message = ts.Diagnostics.Referenced_via_0_from_file_1; + break; + case ts.FileIncludeKind.TypeReferenceDirective: + message = referenceLocation.packageId ? + ts.Diagnostics.Type_library_referenced_via_0_from_file_1_with_packageId_2 : + ts.Diagnostics.Type_library_referenced_via_0_from_file_1; + break; + case ts.FileIncludeKind.LibReferenceDirective: + ts.Debug.assert(!referenceLocation.packageId); + message = ts.Diagnostics.Library_referenced_via_0_from_file_1; + break; + default: + ts.Debug.assertNever(reason); + } + return ts.chainDiagnosticMessages( + /*details*/ undefined, message, referenceText, toFileName(referenceLocation.file, fileNameConvertor), referenceLocation.packageId && ts.packageIdToString(referenceLocation.packageId)); + } + switch (reason.kind) { + case ts.FileIncludeKind.RootFile: + if (!((_a = options.configFile) === null || _a === void 0 ? void 0 : _a.configFileSpecs)) + return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Root_file_specified_for_compilation); + var fileName = ts.getNormalizedAbsolutePath(program.getRootFileNames()[reason.index], program.getCurrentDirectory()); + var matchedByFiles = getMatchedFileSpec(program, fileName); + if (matchedByFiles) + return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Part_of_files_list_in_tsconfig_json); + var matchedByInclude = getMatchedIncludeSpec(program, fileName); + return matchedByInclude ? + ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.Matched_by_include_pattern_0_in_1, matchedByInclude, toFileName(options.configFile, fileNameConvertor)) : + // Could be additional files specified as roots + ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Root_file_specified_for_compilation); + case ts.FileIncludeKind.SourceFromProjectReference: + case ts.FileIncludeKind.OutputFromProjectReference: + var isOutput = reason.kind === ts.FileIncludeKind.OutputFromProjectReference; + var referencedResolvedRef = ts.Debug.checkDefined((_b = program.getResolvedProjectReferences()) === null || _b === void 0 ? void 0 : _b[reason.index]); + return ts.chainDiagnosticMessages( + /*details*/ undefined, ts.outFile(options) ? + isOutput ? + ts.Diagnostics.Output_from_referenced_project_0_included_because_1_specified : + ts.Diagnostics.Source_from_referenced_project_0_included_because_1_specified : + isOutput ? + ts.Diagnostics.Output_from_referenced_project_0_included_because_module_is_specified_as_none : + ts.Diagnostics.Source_from_referenced_project_0_included_because_module_is_specified_as_none, toFileName(referencedResolvedRef.sourceFile.fileName, fileNameConvertor), options.outFile ? "--outFile" : "--out"); + case ts.FileIncludeKind.AutomaticTypeDirectiveFile: + return ts.chainDiagnosticMessages( + /*details*/ undefined, options.types ? + reason.packageId ? + ts.Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1 : + ts.Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions : + reason.packageId ? + ts.Diagnostics.Entry_point_for_implicit_type_library_0_with_packageId_1 : + ts.Diagnostics.Entry_point_for_implicit_type_library_0, reason.typeReference, reason.packageId && ts.packageIdToString(reason.packageId)); + case ts.FileIncludeKind.LibFile: + if (reason.index !== undefined) + return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Library_0_specified_in_compilerOptions, options.lib[reason.index]); + var target = ts.forEachEntry(ts.targetOptionDeclaration.type, function (value, key) { return value === options.target ? key : undefined; }); + return ts.chainDiagnosticMessages( + /*details*/ undefined, target ? + ts.Diagnostics.Default_library_for_target_0 : + ts.Diagnostics.Default_library, target); + default: + ts.Debug.assertNever(reason); + } + } + ts.fileIncludeReasonToDiagnostics = fileIncludeReasonToDiagnostics; + function toFileName(file, fileNameConvertor) { + var fileName = ts.isString(file) ? file : file.fileName; + return fileNameConvertor ? fileNameConvertor(fileName) : fileName; + } /** * Helper that emit files, report diagnostics and lists emitted and/or source files depending on compiler options */ - function emitFilesAndReportErrors(program, reportDiagnostic, writeFileName, reportSummary, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { + function emitFilesAndReportErrors(program, reportDiagnostic, write, reportSummary, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { var isListFilesOnly = !!program.getCompilerOptions().listFilesOnly; // First get and report any syntactic errors. var allDiagnostics = program.getConfigFileParsingDiagnostics().slice(); @@ -110781,13 +112361,13 @@ var ts; ts.addRange(allDiagnostics, emitDiagnostics); var diagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics); diagnostics.forEach(reportDiagnostic); - if (writeFileName) { + if (write) { var currentDir_1 = program.getCurrentDirectory(); ts.forEach(emittedFiles, function (file) { var filepath = ts.getNormalizedAbsolutePath(file, currentDir_1); - writeFileName("TSFILE: " + filepath); + write("TSFILE: " + filepath); }); - listFiles(program, writeFileName); + listFiles(program, write); } if (reportSummary) { reportSummary(getErrorCountForSummary(diagnostics)); @@ -110798,8 +112378,8 @@ var ts; }; } ts.emitFilesAndReportErrors = emitFilesAndReportErrors; - function emitFilesAndReportErrorsAndGetExitStatus(program, reportDiagnostic, writeFileName, reportSummary, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { - var _a = emitFilesAndReportErrors(program, reportDiagnostic, writeFileName, reportSummary, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers), emitResult = _a.emitResult, diagnostics = _a.diagnostics; + function emitFilesAndReportErrorsAndGetExitStatus(program, reportDiagnostic, write, reportSummary, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { + var _a = emitFilesAndReportErrors(program, reportDiagnostic, write, reportSummary, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers), emitResult = _a.emitResult, diagnostics = _a.diagnostics; if (emitResult.emitSkipped && diagnostics.length > 0) { // If the emitter didn't emit anything, then pass that value along. return ts.ExitStatus.DiagnosticsPresent_OutputsSkipped; @@ -110828,6 +112408,7 @@ var ts; ts.createWatchHost = createWatchHost; ts.WatchType = { ConfigFile: "Config file", + ExtendedConfigFile: "Extended config file", SourceFile: "Source file", MissingFile: "Missing file", WildcardDirectory: "Wild card directory", @@ -110837,7 +112418,7 @@ var ts; function createWatchFactory(host, options) { var watchLogLevel = host.trace ? options.extendedDiagnostics ? ts.WatchLogLevel.Verbose : options.diagnostics ? ts.WatchLogLevel.TriggerOnly : ts.WatchLogLevel.None : ts.WatchLogLevel.None; var writeLog = watchLogLevel !== ts.WatchLogLevel.None ? (function (s) { return host.trace(s); }) : ts.noop; - var result = ts.getWatchFactory(watchLogLevel, writeLog); + var result = ts.getWatchFactory(host, watchLogLevel, writeLog); result.writeLog = writeLog; return result; } @@ -110906,7 +112487,7 @@ var ts; for (var _i = 0; _i < arguments.length; _i++) { args[_i] = arguments[_i]; } - var result = originalGetSourceFile.call.apply(originalGetSourceFile, __spreadArrays([compilerHost], args)); + var result = originalGetSourceFile.call.apply(originalGetSourceFile, __spreadArray([compilerHost], args)); if (result) { result.version = computeHash(result.text); } @@ -110945,13 +112526,13 @@ var ts; */ function createWatchCompilerHost(system, createProgram, reportDiagnostic, reportWatchStatus) { if (system === void 0) { system = ts.sys; } - var writeFileName = function (s) { return system.write(s + system.newLine); }; + var write = function (s) { return system.write(s + system.newLine); }; var result = createProgramHost(system, createProgram); ts.copyProperties(result, createWatchHost(system, reportWatchStatus)); result.afterProgramCreate = function (builderProgram) { var compilerOptions = builderProgram.getCompilerOptions(); var newLine = ts.getNewLineCharacter(compilerOptions, function () { return system.newLine; }); - emitFilesAndReportErrors(builderProgram, reportDiagnostic, writeFileName, function (errorCount) { return result.onWatchStatusChange(ts.createCompilerDiagnostic(getWatchErrorSummaryDiagnosticMessage(errorCount), errorCount), newLine, compilerOptions, errorCount); }); + emitFilesAndReportErrors(builderProgram, reportDiagnostic, write, function (errorCount) { return result.onWatchStatusChange(ts.createCompilerDiagnostic(getWatchErrorSummaryDiagnosticMessage(errorCount), errorCount), newLine, compilerOptions, errorCount); }); }; return result; } @@ -111067,18 +112648,19 @@ var ts; function createWatchProgram(host) { var builderProgram; var reloadLevel; // level to indicate if the program needs to be reloaded from config file/just filenames etc + var extendedConfigFilesMap; // Map of file watchers for the extended config files var missingFilesMap; // Map of file watchers for the missing files var watchedWildcardDirectories; // map of watchers for the wild card directories in the config file var timerToUpdateProgram; // timer callback to recompile the program var timerToInvalidateFailedLookupResolutions; // timer callback to invalidate resolutions for changes in failed lookup locations var sourceFilesCache = new ts.Map(); // Cache that stores the source file and version info - var missingFilePathsRequestedForRelease; // These paths are held temparirly so that we can remove the entry from source file cache if the file is not tracked by missing files + var missingFilePathsRequestedForRelease; // These paths are held temporarily so that we can remove the entry from source file cache if the file is not tracked by missing files var hasChangedCompilerOptions = false; // True if the compiler options have changed between compilations var useCaseSensitiveFileNames = host.useCaseSensitiveFileNames(); var currentDirectory = host.getCurrentDirectory(); var configFileName = host.configFileName, _a = host.optionsToExtend, optionsToExtendForConfigFile = _a === void 0 ? {} : _a, watchOptionsToExtend = host.watchOptionsToExtend, extraFileExtensions = host.extraFileExtensions, createProgram = host.createProgram; var rootFileNames = host.rootFiles, compilerOptions = host.options, watchOptions = host.watchOptions, projectReferences = host.projectReferences; - var configFileSpecs; + var wildcardDirectories; var configFileParsingDiagnostics; var canConfigFileJsonReportNoInputFiles = false; var hasChangedConfigFileParsingErrors = false; @@ -111098,12 +112680,12 @@ var ts; parseConfigFile(); newLine = updateNewLine(); } - var _b = ts.createWatchFactory(host, compilerOptions), watchFile = _b.watchFile, watchFilePath = _b.watchFilePath, watchDirectory = _b.watchDirectory, writeLog = _b.writeLog; + var _b = ts.createWatchFactory(host, compilerOptions), watchFile = _b.watchFile, watchDirectory = _b.watchDirectory, writeLog = _b.writeLog; var getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); writeLog("Current directory: " + currentDirectory + " CaseSensitiveFileNames: " + useCaseSensitiveFileNames); var configFileWatcher; if (configFileName) { - configFileWatcher = watchFile(host, configFileName, scheduleProgramReload, ts.PollingInterval.High, watchOptions, ts.WatchType.ConfigFile); + configFileWatcher = watchFile(configFileName, scheduleProgramReload, ts.PollingInterval.High, watchOptions, ts.WatchType.ConfigFile); } var compilerHost = ts.createCompilerHostFromProgramHost(host, function () { return compilerOptions; }, directoryStructureHost); ts.setGetSourceFileAsHashVersioned(compilerHost, host); @@ -111114,7 +112696,7 @@ var ts; for (var _i = 1; _i < arguments.length; _i++) { args[_i - 1] = arguments[_i]; } - return getVersionedSourceFileByPath.apply(void 0, __spreadArrays([fileName, toPath(fileName)], args)); + return getVersionedSourceFileByPath.apply(void 0, __spreadArray([fileName, toPath(fileName)], args)); }; compilerHost.getSourceFileByPath = getVersionedSourceFileByPath; compilerHost.getNewLine = function () { return newLine; }; @@ -111124,8 +112706,8 @@ var ts; compilerHost.toPath = toPath; compilerHost.getCompilationSettings = function () { return compilerOptions; }; compilerHost.useSourceOfProjectReferenceRedirect = ts.maybeBind(host, host.useSourceOfProjectReferenceRedirect); - compilerHost.watchDirectoryOfFailedLookupLocation = function (dir, cb, flags) { return watchDirectory(host, dir, cb, flags, watchOptions, ts.WatchType.FailedLookupLocations); }; - compilerHost.watchTypeRootsDirectory = function (dir, cb, flags) { return watchDirectory(host, dir, cb, flags, watchOptions, ts.WatchType.TypeRoots); }; + compilerHost.watchDirectoryOfFailedLookupLocation = function (dir, cb, flags) { return watchDirectory(dir, cb, flags, watchOptions, ts.WatchType.FailedLookupLocations); }; + compilerHost.watchTypeRootsDirectory = function (dir, cb, flags) { return watchDirectory(dir, cb, flags, watchOptions, ts.WatchType.TypeRoots); }; compilerHost.getCachedDirectoryStructureHost = function () { return cachedDirectoryStructureHost; }; compilerHost.scheduleInvalidateResolutionsOfFailedLookupLocations = scheduleInvalidateResolutionsOfFailedLookupLocations; compilerHost.onInvalidatedResolution = scheduleProgramUpdate; @@ -111162,6 +112744,8 @@ var ts; synchronizeProgram(); // Update the wild card directory watch watchConfigFileWildCardDirectories(); + // Update extended config file watch + watchExtendedConfigFiles(); return configFileName ? { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, close: close } : { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, updateRootFileNames: updateRootFileNames, close: close }; @@ -111178,6 +112762,10 @@ var ts; configFileWatcher.close(); configFileWatcher = undefined; } + if (extendedConfigFilesMap) { + ts.clearMap(extendedConfigFilesMap, ts.closeFileWatcher); + extendedConfigFilesMap = undefined; + } if (watchedWildcardDirectories) { ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcherOf); watchedWildcardDirectories = undefined; @@ -111293,7 +112881,7 @@ var ts; hostSourceFile.sourceFile = sourceFile; hostSourceFile.version = sourceFile.version; if (!hostSourceFile.fileWatcher) { - hostSourceFile.fileWatcher = watchFilePath(host, fileName, onSourceFileChange, ts.PollingInterval.Low, watchOptions, path, ts.WatchType.SourceFile); + hostSourceFile.fileWatcher = watchFilePath(path, fileName, onSourceFileChange, ts.PollingInterval.Low, watchOptions, ts.WatchType.SourceFile); } } else { @@ -111306,7 +112894,7 @@ var ts; } else { if (sourceFile) { - var fileWatcher = watchFilePath(host, fileName, onSourceFileChange, ts.PollingInterval.Low, watchOptions, path, ts.WatchType.SourceFile); + var fileWatcher = watchFilePath(path, fileName, onSourceFileChange, ts.PollingInterval.Low, watchOptions, ts.WatchType.SourceFile); sourceFilesCache.set(path, { sourceFile: sourceFile, version: sourceFile.version, fileWatcher: fileWatcher }); } else { @@ -111427,11 +113015,10 @@ var ts; } function reloadFileNamesFromConfigFile() { writeLog("Reloading new file names and options"); - var result = ts.getFileNamesFromConfigSpecs(configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost, extraFileExtensions); - if (ts.updateErrorForNoInputFiles(result, ts.getNormalizedAbsolutePath(configFileName, currentDirectory), configFileSpecs, configFileParsingDiagnostics, canConfigFileJsonReportNoInputFiles)) { + rootFileNames = ts.getFileNamesFromConfigSpecs(compilerOptions.configFile.configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost, extraFileExtensions); + if (ts.updateErrorForNoInputFiles(rootFileNames, ts.getNormalizedAbsolutePath(configFileName, currentDirectory), compilerOptions.configFile.configFileSpecs, configFileParsingDiagnostics, canConfigFileJsonReportNoInputFiles)) { hasChangedConfigFileParsingErrors = true; } - rootFileNames = result.fileNames; // Update the program synchronizeProgram(); } @@ -111446,6 +113033,8 @@ var ts; synchronizeProgram(); // Update the wild card directory watch watchConfigFileWildCardDirectories(); + // Update extended config file watch + watchExtendedConfigFiles(); } function parseConfigFile() { setConfigFileParsingResult(ts.getParsedCommandLineOfConfigFile(configFileName, optionsToExtendForConfigFile, parseConfigFileHost, /*extendedConfigCache*/ undefined, watchOptionsToExtend, extraFileExtensions)); // TODO: GH#18217 @@ -111454,12 +113043,15 @@ var ts; rootFileNames = configFileParseResult.fileNames; compilerOptions = configFileParseResult.options; watchOptions = configFileParseResult.watchOptions; - configFileSpecs = configFileParseResult.configFileSpecs; // TODO: GH#18217 projectReferences = configFileParseResult.projectReferences; + wildcardDirectories = configFileParseResult.wildcardDirectories; configFileParsingDiagnostics = ts.getConfigFileParsingDiagnostics(configFileParseResult).slice(); canConfigFileJsonReportNoInputFiles = ts.canJsonReportNoInputFiles(configFileParseResult.raw); hasChangedConfigFileParsingErrors = true; } + function watchFilePath(path, file, callback, pollingInterval, options, watchType) { + return watchFile(file, function (fileName, eventKind) { return callback(fileName, eventKind, path); }, pollingInterval, options, watchType); + } function onSourceFileChange(fileName, eventKind, path) { updateCachedSystemWithFile(fileName, path, eventKind); // Update the source file cache @@ -111477,7 +113069,7 @@ var ts; } } function watchMissingFilePath(missingFilePath) { - return watchFilePath(host, missingFilePath, onMissingFileChange, ts.PollingInterval.Medium, watchOptions, missingFilePath, ts.WatchType.MissingFile); + return watchFilePath(missingFilePath, missingFilePath, onMissingFileChange, ts.PollingInterval.Medium, watchOptions, ts.WatchType.MissingFile); } function onMissingFileChange(fileName, eventKind, missingFilePath) { updateCachedSystemWithFile(fileName, missingFilePath, eventKind); @@ -111491,15 +113083,15 @@ var ts; } } function watchConfigFileWildCardDirectories() { - if (configFileSpecs) { - ts.updateWatchingWildcardDirectories(watchedWildcardDirectories || (watchedWildcardDirectories = new ts.Map()), new ts.Map(ts.getEntries(configFileSpecs.wildcardDirectories)), watchWildcardDirectory); + if (wildcardDirectories) { + ts.updateWatchingWildcardDirectories(watchedWildcardDirectories || (watchedWildcardDirectories = new ts.Map()), new ts.Map(ts.getEntries(wildcardDirectories)), watchWildcardDirectory); } else if (watchedWildcardDirectories) { ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcherOf); } } function watchWildcardDirectory(directory, flags) { - return watchDirectory(host, directory, function (fileOrDirectory) { + return watchDirectory(directory, function (fileOrDirectory) { ts.Debug.assert(!!configFileName); var fileOrDirectoryPath = toPath(fileOrDirectory); // Since the file existence changed, update the sourceFiles cache @@ -111512,7 +113104,6 @@ var ts; fileOrDirectory: fileOrDirectory, fileOrDirectoryPath: fileOrDirectoryPath, configFileName: configFileName, - configFileSpecs: configFileSpecs, extraFileExtensions: extraFileExtensions, options: compilerOptions, program: getCurrentBuilderProgram(), @@ -111529,6 +113120,19 @@ var ts; } }, flags, watchOptions, ts.WatchType.WildcardDirectory); } + function watchExtendedConfigFiles() { + var _a; + // Update the extended config files watcher + ts.mutateMap(extendedConfigFilesMap || (extendedConfigFilesMap = new ts.Map()), ts.arrayToMap(((_a = compilerOptions.configFile) === null || _a === void 0 ? void 0 : _a.extendedSourceFiles) || ts.emptyArray, toPath), { + // Watch the extended config files + createNewValue: watchExtendedConfigFile, + // Config files that are no longer extended should no longer be watched. + onDeleteValue: ts.closeFileWatcher + }); + } + function watchExtendedConfigFile(extendedConfigFile) { + return watchFile(extendedConfigFile, scheduleProgramReload, ts.PollingInterval.High, watchOptions, ts.WatchType.ExtendedConfigFile); + } } ts.createWatchProgram = createWatchProgram; })(ts || (ts = {})); @@ -111693,14 +113297,14 @@ var ts; return ts.loadWithLocalCache(ts.Debug.checkEachDefined(moduleNames), containingFile, redirectedReference, loader_3); }; } - var _a = ts.createWatchFactory(hostWithWatch, options), watchFile = _a.watchFile, watchFilePath = _a.watchFilePath, watchDirectory = _a.watchDirectory, writeLog = _a.writeLog; + var _a = ts.createWatchFactory(hostWithWatch, options), watchFile = _a.watchFile, watchDirectory = _a.watchDirectory, writeLog = _a.writeLog; var state = { host: host, hostWithWatch: hostWithWatch, currentDirectory: currentDirectory, getCanonicalFileName: getCanonicalFileName, parseConfigFileHost: ts.parseConfigHostFromCompilerHostLike(host), - writeFileName: host.trace ? function (s) { return host.trace(s); } : undefined, + write: ts.maybeBind(host, host.trace), // State of solution options: options, baseCompilerOptions: baseCompilerOptions, @@ -111731,10 +113335,10 @@ var ts; allWatchedWildcardDirectories: new ts.Map(), allWatchedInputFiles: new ts.Map(), allWatchedConfigFiles: new ts.Map(), + allWatchedExtendedConfigFiles: new ts.Map(), timerToBuildInvalidatedProject: undefined, reportFileChangeDetected: false, watchFile: watchFile, - watchFilePath: watchFilePath, watchDirectory: watchDirectory, writeLog: writeLog, }; @@ -111841,6 +113445,14 @@ var ts; // Remove watches for the program no longer in the solution if (state.watch) { ts.mutateMapSkippingNewValues(state.allWatchedConfigFiles, currentProjects, { onDeleteValue: ts.closeFileWatcher }); + state.allWatchedExtendedConfigFiles.forEach(function (watcher) { + watcher.projects.forEach(function (project) { + if (!currentProjects.has(project)) { + watcher.projects.delete(project); + } + }); + watcher.close(); + }); ts.mutateMapSkippingNewValues(state.allWatchedWildcardDirectories, currentProjects, { onDeleteValue: function (existingMap) { return existingMap.forEach(ts.closeFileWatcherOf); } }); ts.mutateMapSkippingNewValues(state.allWatchedInputFiles, currentProjects, { onDeleteValue: function (existingMap) { return existingMap.forEach(ts.closeFileWatcher); } }); } @@ -111875,7 +113487,7 @@ var ts; for (var _i = 0; _i < arguments.length; _i++) { args[_i] = arguments[_i]; } - return originalGetSourceFile.call.apply(originalGetSourceFile, __spreadArrays([compilerHost], args)); + return originalGetSourceFile.call.apply(originalGetSourceFile, __spreadArray([compilerHost], args)); }), originalReadFile = _a.originalReadFile, originalFileExists = _a.originalFileExists, originalDirectoryExists = _a.originalDirectoryExists, originalCreateDirectory = _a.originalCreateDirectory, originalWriteFile = _a.originalWriteFile, getSourceFileWithCache = _a.getSourceFileWithCache, readFileWithCache = _a.readFileWithCache; state.readFileWithCache = readFileWithCache; compilerHost.getSourceFile = getSourceFileWithCache; @@ -112109,7 +113721,7 @@ var ts; } function getSyntaxDiagnostics(cancellationToken) { ts.Debug.assertIsDefined(program); - handleDiagnostics(__spreadArrays(program.getConfigFileParsingDiagnostics(), program.getOptionsDiagnostics(cancellationToken), program.getGlobalDiagnostics(cancellationToken), program.getSyntacticDiagnostics(/*sourceFile*/ undefined, cancellationToken)), BuildResultFlags.SyntaxErrors, "Syntactic"); + handleDiagnostics(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], program.getConfigFileParsingDiagnostics()), program.getOptionsDiagnostics(cancellationToken)), program.getGlobalDiagnostics(cancellationToken)), program.getSyntacticDiagnostics(/*sourceFile*/ undefined, cancellationToken)), BuildResultFlags.SyntaxErrors, "Syntactic"); } function getSemanticDiagnostics(cancellationToken) { handleDiagnostics(ts.Debug.checkDefined(program).getSemanticDiagnostics(/*sourceFile*/ undefined, cancellationToken), BuildResultFlags.TypeErrors, "Semantic"); @@ -112124,7 +113736,7 @@ var ts; var reportDeclarationDiagnostics = function (d) { return (declDiagnostics || (declDiagnostics = [])).push(d); }; var outputFiles = []; var emitResult = ts.emitFilesAndReportErrors(program, reportDeclarationDiagnostics, - /*writeFileName*/ undefined, + /*write*/ undefined, /*reportSummary*/ undefined, function (name, text, writeByteOrderMark) { return outputFiles.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark }); }, cancellationToken, /*emitOnlyDts*/ false, customTransformers).emitResult; // Don't emit .d.ts if there are decl file errors @@ -112172,10 +113784,10 @@ var ts; var emitResult = program.emitBuildInfo(writeFileCallback, cancellationToken); if (emitResult.diagnostics.length) { reportErrors(state, emitResult.diagnostics); - state.diagnostics.set(projectPath, __spreadArrays(state.diagnostics.get(projectPath), emitResult.diagnostics)); + state.diagnostics.set(projectPath, __spreadArray(__spreadArray([], state.diagnostics.get(projectPath)), emitResult.diagnostics)); buildResult = BuildResultFlags.EmitErrors & buildResult; } - if (emitResult.emittedFiles && state.writeFileName) { + if (emitResult.emittedFiles && state.write) { emitResult.emittedFiles.forEach(function (name) { return listEmittedFile(state, config, name); }); } afterProgramDone(state, program, config); @@ -112189,7 +113801,7 @@ var ts; (_a = buildErrors(state, projectPath, program, config, emitDiagnostics, BuildResultFlags.EmitErrors, "Emit"), buildResult = _a.buildResult, step = _a.step); return emitDiagnostics; } - if (state.writeFileName) { + if (state.write) { emittedOutputs.forEach(function (name) { return listEmittedFile(state, config, name); }); } // Update time stamps for rest of the outputs @@ -112319,14 +113931,14 @@ var ts; } if (reloadLevel === ts.ConfigFileProgramReloadLevel.Full) { watchConfigFile(state, project, projectPath, config); + watchExtendedConfigFiles(state, projectPath, config); watchWildCardDirectories(state, project, projectPath, config); watchInputFiles(state, project, projectPath, config); } else if (reloadLevel === ts.ConfigFileProgramReloadLevel.Partial) { // Update file names - var result = ts.getFileNamesFromConfigSpecs(config.configFileSpecs, ts.getDirectoryPath(project), config.options, state.parseConfigFileHost); - ts.updateErrorForNoInputFiles(result, project, config.configFileSpecs, config.errors, ts.canJsonReportNoInputFiles(config.raw)); - config.fileNames = result.fileNames; + config.fileNames = ts.getFileNamesFromConfigSpecs(config.options.configFile.configFileSpecs, ts.getDirectoryPath(project), config.options, state.parseConfigFileHost); + ts.updateErrorForNoInputFiles(config.fileNames, project, config.options.configFile.configFileSpecs, config.errors, ts.canJsonReportNoInputFiles(config.raw)); watchInputFiles(state, project, projectPath, config); } var status = getUpToDateStatus(state, config, projectPath); @@ -112370,9 +113982,9 @@ var ts; return undefined; } function listEmittedFile(_a, proj, file) { - var writeFileName = _a.writeFileName; - if (writeFileName && proj.options.listEmittedFiles) { - writeFileName("TSFILE: " + file); + var write = _a.write; + if (write && proj.options.listEmittedFiles) { + write("TSFILE: " + file); } } function getOldProgram(_a, proj, parsed) { @@ -112386,8 +113998,8 @@ var ts; } function afterProgramDone(state, program, config) { if (program) { - if (program && state.writeFileName) - ts.listFiles(program, state.writeFileName); + if (program && state.write) + ts.listFiles(program, state.write); if (state.host.afterProgramEmitAndDiagnostics) { state.host.afterProgramEmitAndDiagnostics(program); } @@ -112401,7 +114013,6 @@ var ts; function buildErrors(state, resolvedPath, program, config, diagnostics, buildResult, errorType) { var canEmitBuildInfo = !(buildResult & BuildResultFlags.SyntaxErrors) && program && !ts.outFile(program.getCompilerOptions()); reportAndStoreErrors(state, resolvedPath, diagnostics); - // List files if any other build error using program (emit errors already report files) state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.Unbuildable, reason: errorType + " errors" }); if (canEmitBuildInfo) return { buildResult: buildResult, step: BuildStep.EmitBuildInfo }; @@ -112851,20 +114462,27 @@ var ts; function watchConfigFile(state, resolved, resolvedPath, parsed) { if (!state.watch || state.allWatchedConfigFiles.has(resolvedPath)) return; - state.allWatchedConfigFiles.set(resolvedPath, state.watchFile(state.hostWithWatch, resolved, function () { + state.allWatchedConfigFiles.set(resolvedPath, state.watchFile(resolved, function () { invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Full); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.ConfigFile, resolved)); } + function watchExtendedConfigFiles(state, resolvedPath, parsed) { + ts.updateSharedExtendedConfigFileWatcher(resolvedPath, parsed, state.allWatchedExtendedConfigFiles, function (extendedConfigFileName, extendedConfigFilePath) { return state.watchFile(extendedConfigFileName, function () { + var _a; + return (_a = state.allWatchedExtendedConfigFiles.get(extendedConfigFilePath)) === null || _a === void 0 ? void 0 : _a.projects.forEach(function (projectConfigFilePath) { + return invalidateProjectAndScheduleBuilds(state, projectConfigFilePath, ts.ConfigFileProgramReloadLevel.Full); + }); + }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.ExtendedConfigFile); }, function (fileName) { return toPath(state, fileName); }); + } function watchWildCardDirectories(state, resolved, resolvedPath, parsed) { if (!state.watch) return; - ts.updateWatchingWildcardDirectories(getOrCreateValueMapFromConfigFileMap(state.allWatchedWildcardDirectories, resolvedPath), new ts.Map(ts.getEntries(parsed.configFileSpecs.wildcardDirectories)), function (dir, flags) { return state.watchDirectory(state.hostWithWatch, dir, function (fileOrDirectory) { + ts.updateWatchingWildcardDirectories(getOrCreateValueMapFromConfigFileMap(state.allWatchedWildcardDirectories, resolvedPath), new ts.Map(ts.getEntries(parsed.wildcardDirectories)), function (dir, flags) { return state.watchDirectory(dir, function (fileOrDirectory) { if (ts.isIgnoredFileFromWildCardWatching({ watchedDirPath: toPath(state, dir), fileOrDirectory: fileOrDirectory, fileOrDirectoryPath: toPath(state, fileOrDirectory), configFileName: resolved, - configFileSpecs: parsed.configFileSpecs, currentDirectory: state.currentDirectory, options: parsed.options, program: state.builderPrograms.get(resolvedPath), @@ -112879,7 +114497,7 @@ var ts; if (!state.watch) return; ts.mutateMap(getOrCreateValueMapFromConfigFileMap(state.allWatchedInputFiles, resolvedPath), ts.arrayToMap(parsed.fileNames, function (fileName) { return toPath(state, fileName); }), { - createNewValue: function (path, input) { return state.watchFilePath(state.hostWithWatch, input, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.Low, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, path, ts.WatchType.SourceFile, resolved); }, + createNewValue: function (_path, input) { return state.watchFile(input, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.Low, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.SourceFile, resolved); }, onDeleteValue: ts.closeFileWatcher, }); } @@ -112893,6 +114511,7 @@ var ts; var cfg = parseConfigFile(state, resolved, resolvedPath); // Watch this file watchConfigFile(state, resolved, resolvedPath, cfg); + watchExtendedConfigFiles(state, resolvedPath, cfg); if (cfg) { // Update watchers for wildcard directories watchWildCardDirectories(state, resolved, resolvedPath, cfg); @@ -112903,6 +114522,10 @@ var ts; } function stopWatching(state) { ts.clearMap(state.allWatchedConfigFiles, ts.closeFileWatcher); + ts.clearMap(state.allWatchedExtendedConfigFiles, function (watcher) { + watcher.projects.clear(); + watcher.close(); + }); ts.clearMap(state.allWatchedWildcardDirectories, function (watchedWildcardDirectories) { return ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcherOf); }); ts.clearMap(state.allWatchedInputFiles, function (watchedWildcardDirectories) { return ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcher); }); } @@ -112937,16 +114560,15 @@ var ts; for (var _i = 2; _i < arguments.length; _i++) { args[_i - 2] = arguments[_i]; } - state.host.reportSolutionBuilderStatus(ts.createCompilerDiagnostic.apply(void 0, __spreadArrays([message], args))); + state.host.reportSolutionBuilderStatus(ts.createCompilerDiagnostic.apply(void 0, __spreadArray([message], args))); } function reportWatchStatus(state, message) { + var _a, _b; var args = []; for (var _i = 2; _i < arguments.length; _i++) { args[_i - 2] = arguments[_i]; } - if (state.hostWithWatch.onWatchStatusChange) { - state.hostWithWatch.onWatchStatusChange(ts.createCompilerDiagnostic.apply(void 0, __spreadArrays([message], args)), state.host.getNewLine(), state.baseCompilerOptions); - } + (_b = (_a = state.hostWithWatch).onWatchStatusChange) === null || _b === void 0 ? void 0 : _b.call(_a, ts.createCompilerDiagnostic.apply(void 0, __spreadArray([message], args)), state.host.getNewLine(), state.baseCompilerOptions); } function reportErrors(_a, errors) { var host = _a.host; @@ -114463,6 +116085,25 @@ var ts; return functionKeyword; } } + function getAncestorTypeNode(node) { + var lastTypeNode; + ts.findAncestor(node, function (a) { + if (ts.isTypeNode(a)) { + lastTypeNode = a; + } + return !ts.isQualifiedName(a.parent) && !ts.isTypeNode(a.parent) && !ts.isTypeElement(a.parent); + }); + return lastTypeNode; + } + function getContextualTypeOrAncestorTypeNodeType(node, checker) { + var contextualType = checker.getContextualType(node); + if (contextualType) { + return contextualType; + } + var ancestorTypeNode = getAncestorTypeNode(node); + return ancestorTypeNode && checker.getTypeAtLocation(ancestorTypeNode); + } + ts.getContextualTypeOrAncestorTypeNodeType = getContextualTypeOrAncestorTypeNodeType; function getAdjustedLocationForDeclaration(node, forRename) { if (!forRename) { switch (node.kind) { @@ -115024,6 +116665,22 @@ var ts; } ts.isInsideJsxElement = isInsideJsxElement; function findPrecedingMatchingToken(token, matchingTokenKind, sourceFile) { + var closeTokenText = ts.tokenToString(token.kind); + var matchingTokenText = ts.tokenToString(matchingTokenKind); + var tokenFullStart = token.getFullStart(); + // Text-scan based fast path - can be bamboozled by comments and other trivia, but often provides + // a good, fast approximation without too much extra work in the cases where it fails. + var bestGuessIndex = sourceFile.text.lastIndexOf(matchingTokenText, tokenFullStart); + if (bestGuessIndex === -1) { + return undefined; // if the token text doesn't appear in the file, there can't be a match - super fast bail + } + // we can only use the textual result directly if we didn't have to count any close tokens within the range + if (sourceFile.text.lastIndexOf(closeTokenText, tokenFullStart - 1) < bestGuessIndex) { + var nodeAtGuess = findPrecedingToken(bestGuessIndex + 1, sourceFile); + if (nodeAtGuess && nodeAtGuess.kind === matchingTokenKind) { + return nodeAtGuess; + } + } var tokenKind = token.kind; var remainingMatchingTokens = 0; while (true) { @@ -115068,6 +116725,11 @@ var ts; ts.getPossibleGenericSignatures = getPossibleGenericSignatures; // Get info for an expression like `f <` that may be the start of type arguments. function getPossibleTypeArgumentsInfo(tokenIn, sourceFile) { + // This is a rare case, but one that saves on a _lot_ of work if true - if the source file has _no_ `<` character, + // then there obviously can't be any type arguments - no expensive brace-matching backwards scanning required + if (sourceFile.text.lastIndexOf("<", tokenIn ? tokenIn.pos : sourceFile.text.length) === -1) { + return undefined; + } var token = tokenIn; // This function determines if the node could be type argument position // Since during editing, when type argument list is not complete, @@ -115174,9 +116836,12 @@ var ts; // Note: getWidth() does not take trivia into account. return n.kind === 1 /* EndOfFileToken */ ? !!n.jsDoc : n.getWidth(sourceFile) !== 0; } - function getNodeModifiers(node) { - var flags = ts.isDeclaration(node) ? ts.getCombinedNodeFlagsAlwaysIncludeJSDoc(node) : 0 /* None */; + function getNodeModifiers(node, excludeFlags) { + if (excludeFlags === void 0) { excludeFlags = 0 /* None */; } var result = []; + var flags = ts.isDeclaration(node) + ? ts.getCombinedNodeFlagsAlwaysIncludeJSDoc(node) & ~excludeFlags + : 0 /* None */; if (flags & 8 /* Private */) result.push("private" /* privateMemberModifier */); if (flags & 16 /* Protected */) @@ -115333,6 +116998,7 @@ var ts; 155 /* BigIntKeyword */, 131 /* BooleanKeyword */, 94 /* FalseKeyword */, + 135 /* InferKeyword */, 138 /* KeyOfKeyword */, 141 /* NeverKeyword */, 103 /* NullKeyword */, @@ -115416,7 +117082,9 @@ var ts; getSourceFiles: function () { return program.getSourceFiles(); }, redirectTargetsMap: program.redirectTargetsMap, getProjectReferenceRedirect: function (fileName) { return program.getProjectReferenceRedirect(fileName); }, - isSourceOfProjectReferenceRedirect: function (fileName) { return program.isSourceOfProjectReferenceRedirect(fileName); } + isSourceOfProjectReferenceRedirect: function (fileName) { return program.isSourceOfProjectReferenceRedirect(fileName); }, + getNearestAncestorDirectoryWithPackageJson: ts.maybeBind(host, host.getNearestAncestorDirectoryWithPackageJson), + getFileIncludeReasons: function () { return program.getFileIncludeReasons(); }, }; } ts.createModuleSpecifierResolutionHost = createModuleSpecifierResolutionHost; @@ -115496,37 +117164,6 @@ var ts; return typeOfPattern && checker.getPropertyOfType(typeOfPattern, bindingElement.name.text); } ts.getPropertySymbolFromBindingElement = getPropertySymbolFromBindingElement; - /** - * Find symbol of the given property-name and add the symbol to the given result array - * @param symbol a symbol to start searching for the given propertyName - * @param propertyName a name of property to search for - * @param result an array of symbol of found property symbols - * @param previousIterationSymbolsCache a cache of symbol from previous iterations of calling this function to prevent infinite revisiting of the same symbol. - * The value of previousIterationSymbol is undefined when the function is first called. - */ - function getPropertySymbolsFromBaseTypes(symbol, propertyName, checker, cb) { - var seen = new ts.Map(); - return recur(symbol); - function recur(symbol) { - // Use `addToSeen` to ensure we don't infinitely recurse in this situation: - // interface C extends C { - // /*findRef*/propName: string; - // } - if (!(symbol.flags & (32 /* Class */ | 64 /* Interface */)) || !ts.addToSeen(seen, ts.getSymbolId(symbol))) - return; - return ts.firstDefined(symbol.declarations, function (declaration) { return ts.firstDefined(ts.getAllSuperTypeNodes(declaration), function (typeReference) { - var type = checker.getTypeAtLocation(typeReference); - var propertySymbol = type && type.symbol && checker.getPropertyOfType(type, propertyName); - // Visit the typeReference as well to see if it directly or indirectly uses that property - return type && propertySymbol && (ts.firstDefined(checker.getRootSymbols(propertySymbol), cb) || recur(type.symbol)); - }); }); - } - } - ts.getPropertySymbolsFromBaseTypes = getPropertySymbolsFromBaseTypes; - function isMemberSymbolInBaseType(memberSymbol, checker) { - return getPropertySymbolsFromBaseTypes(memberSymbol.parent, memberSymbol.name, checker, function (_) { return true; }) || false; - } - ts.isMemberSymbolInBaseType = isMemberSymbolInBaseType; function getParentNodeInSpan(node, file, span) { if (!node) return undefined; @@ -115806,7 +117443,8 @@ var ts; */ function getNewLineOrDefaultFromHost(host, formatSettings) { var _a; - return (formatSettings === null || formatSettings === void 0 ? void 0 : formatSettings.newLineCharacter) || ((_a = host.getNewLine) === null || _a === void 0 ? void 0 : _a.call(host)) || + return (formatSettings === null || formatSettings === void 0 ? void 0 : formatSettings.newLineCharacter) || + ((_a = host.getNewLine) === null || _a === void 0 ? void 0 : _a.call(host)) || carriageReturnLineFeed; } ts.getNewLineOrDefaultFromHost = getNewLineOrDefaultFromHost; @@ -116109,7 +117747,7 @@ var ts; // Editors can pass in undefined or empty string - we want to infer the preference in those cases. var quotePreference = getQuotePreference(sourceFile, preferences); var quoted = JSON.stringify(text); - return quotePreference === 0 /* Single */ ? "'" + ts.stripQuotes(quoted).replace("'", "\\'").replace('\\"', '"') + "'" : quoted; + return quotePreference === 0 /* Single */ ? "'" + ts.stripQuotes(quoted).replace(/'/g, "\\'").replace(/\\"/g, '"') + "'" : quoted; } ts.quote = quote; function isEqualityOperatorKind(kind) { @@ -116476,9 +118114,9 @@ var ts; } ts.firstOrOnly = firstOrOnly; function getNameForExportedSymbol(symbol, scriptTarget) { - if (symbol.escapedName === "export=" /* ExportEquals */ || symbol.escapedName === "default" /* Default */) { + if (!(symbol.flags & 33554432 /* Transient */) && (symbol.escapedName === "export=" /* ExportEquals */ || symbol.escapedName === "default" /* Default */)) { // Name of "export default foo;" is "foo". Name of "export default 0" is the filename converted to camelCase. - return ts.firstDefined(symbol.declarations, function (d) { return ts.isExportAssignment(d) && ts.isIdentifier(d.expression) ? d.expression.text : undefined; }) + return ts.firstDefined(symbol.declarations, function (d) { var _a; return ts.isExportAssignment(d) ? (_a = ts.tryCast(ts.skipOuterExpressions(d.expression), ts.isIdentifier)) === null || _a === void 0 ? void 0 : _a.text : undefined; }) || ts.codefix.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget); } return symbol.name; @@ -117909,7 +119547,7 @@ var ts; // foo({ // '/*completion position*/' // }); - return stringLiteralCompletionsFromProperties(typeChecker.getContextualType(parent.parent)); + return stringLiteralCompletionsForObjectLiteral(typeChecker, parent.parent); } return fromContextualType(); case 202 /* ElementAccessExpression */: { @@ -117990,6 +119628,18 @@ var ts; hasIndexSignature: ts.hasIndexSignature(type) }; } + function stringLiteralCompletionsForObjectLiteral(checker, objectLiteralExpression) { + var contextualType = checker.getContextualType(objectLiteralExpression); + if (!contextualType) + return undefined; + var completionsType = checker.getContextualType(objectLiteralExpression, 4 /* Completions */); + var symbols = Completions.getPropertiesForObjectExpression(contextualType, completionsType, objectLiteralExpression, checker); + return { + kind: 1 /* Properties */, + symbols: symbols, + hasIndexSignature: ts.hasIndexSignature(contextualType) + }; + } function getStringLiteralTypes(type, uniques) { if (uniques === void 0) { uniques = new ts.Map(); } if (!type) @@ -118006,9 +119656,10 @@ var ts; } function addReplacementSpans(text, textStart, names) { var span = getDirectoryFragmentTextSpan(text, textStart); + var wholeSpan = text.length === 0 ? undefined : ts.createTextSpan(textStart, text.length); return names.map(function (_a) { var name = _a.name, kind = _a.kind, extension = _a.extension; - return ({ name: name, kind: kind, extension: extension, span: span }); + return Math.max(name.indexOf(ts.directorySeparator), name.indexOf(ts.altDirectorySeparator)) !== -1 ? { name: name, kind: kind, extension: extension, span: wholeSpan } : { name: name, kind: kind, extension: extension, span: span }; }); } function getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker) { @@ -118053,7 +119704,7 @@ var ts; return ts.containsPath(rootDirectory, scriptDirectory, basePath, ignoreCase) ? scriptDirectory.substr(rootDirectory.length) : undefined; }); // TODO: GH#18217 // Now find a path for each potential directory that is to be merged with the one containing the script - return ts.deduplicate(__spreadArrays(rootDirs.map(function (rootDirectory) { return ts.combinePaths(rootDirectory, relativeDirectory); }), [scriptDirectory]), ts.equateStringsCaseSensitive, ts.compareStringsCaseSensitive); + return ts.deduplicate(__spreadArray(__spreadArray([], rootDirs.map(function (rootDirectory) { return ts.combinePaths(rootDirectory, relativeDirectory); })), [scriptDirectory]), ts.equateStringsCaseSensitive, ts.compareStringsCaseSensitive); } function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment, scriptDirectory, extensionOptions, compilerOptions, host, exclude) { var basePath = compilerOptions.project || host.getCurrentDirectory(); @@ -118260,7 +119911,7 @@ var ts; var name = trimPrefixAndSuffix(dir); return name === undefined ? undefined : directoryResult(name); }); - return __spreadArrays(matches, directories); + return __spreadArray(__spreadArray([], matches), directories); function trimPrefixAndSuffix(path) { var inner = withoutStartAndEnd(ts.normalizePath(path), completePrefix, normalizedSuffix); return inner === undefined ? undefined : removeLeadingDirectorySeparator(inner); @@ -118368,7 +120019,7 @@ var ts; } // Replace everything after the last directory separator that appears function getDirectoryFragmentTextSpan(text, textStart) { - var index = Math.max(text.lastIndexOf(ts.directorySeparator), text.lastIndexOf("\\")); + var index = Math.max(text.lastIndexOf(ts.directorySeparator), text.lastIndexOf(ts.altDirectorySeparator)); var offset = index !== -1 ? index + 1 : 0; // If the range is an identifier, span is unnecessary. var length = text.length - offset; @@ -118515,7 +120166,8 @@ var ts; // cache invalidation in synchronizeHostData). if ((_a = suggestion.symbol.declarations) === null || _a === void 0 ? void 0 : _a.length) { suggestion.symbol = checker.getMergedSymbol(suggestion.origin.isDefaultExport - ? (_b = suggestion.symbol.declarations[0].localSymbol) !== null && _b !== void 0 ? _b : suggestion.symbol.declarations[0].symbol : suggestion.symbol.declarations[0].symbol); + ? (_b = suggestion.symbol.declarations[0].localSymbol) !== null && _b !== void 0 ? _b : suggestion.symbol.declarations[0].symbol + : suggestion.symbol.declarations[0].symbol); } if ((_c = suggestion.origin.moduleSymbol.declarations) === null || _c === void 0 ? void 0 : _c.length) { suggestion.origin.moduleSymbol = checker.getMergedSymbol(suggestion.origin.moduleSymbol.declarations[0].symbol); @@ -118719,7 +120371,7 @@ var ts; return { name: name, kind: ts.SymbolDisplay.getSymbolKind(typeChecker, symbol, location), - kindModifiers: ts.SymbolDisplay.getSymbolModifiers(symbol), + kindModifiers: ts.SymbolDisplay.getSymbolModifiers(typeChecker, symbol), sortText: sortText, source: getSourceFromOrigin(origin), hasAction: origin && originIsExport(origin) || undefined, @@ -118887,7 +120539,7 @@ var ts; var _a = checker.runWithCancellationToken(cancellationToken, function (checker) { return ts.SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, sourceFile, location, location, 7 /* All */); }), displayParts = _a.displayParts, documentation = _a.documentation, symbolKind = _a.symbolKind, tags = _a.tags; - return createCompletionDetails(symbol.name, ts.SymbolDisplay.getSymbolModifiers(symbol), symbolKind, displayParts, documentation, tags, codeActions, sourceDisplay); + return createCompletionDetails(symbol.name, ts.SymbolDisplay.getSymbolModifiers(checker, symbol), symbolKind, displayParts, documentation, tags, codeActions, sourceDisplay); } Completions.createCompletionDetailsForSymbol = createCompletionDetailsForSymbol; function createCompletionDetails(name, kindModifiers, kind, displayParts, documentation, tags, codeActions, source) { @@ -118979,6 +120631,7 @@ var ts; } function getCompletionData(program, log, sourceFile, isUncheckedFile, position, preferences, detailsEntryId, host) { var typeChecker = program.getTypeChecker(); + var compilerOptions = program.getCompilerOptions(); var start = ts.timestamp(); var currentToken = ts.getTokenAtPosition(sourceFile, position); // TODO: GH#15853 // We will check for jsdoc comments with insideComment and getJsDocTagAtPosition. (TODO: that seems rather inefficient to check the same thing so many times.) @@ -119190,6 +120843,7 @@ var ts; var semanticStart = ts.timestamp(); var completionKind = 5 /* None */; var isNewIdentifierLocation = false; + var isNonContextualObjectLiteral = false; var keywordFilters = 0 /* None */; // This also gets mutated in nested-functions after the return var symbols = []; @@ -119465,7 +121119,7 @@ var ts; keywordFilters = tryGetFunctionLikeBodyCompletionContainer(contextToken) ? 5 /* FunctionLikeBodyKeywords */ : 1 /* All */; // Get all entities in the current scope. completionKind = 1 /* Global */; - isNewIdentifierLocation = isNewIdentifierDefinitionLocation(contextToken); + isNewIdentifierLocation = isNewIdentifierDefinitionLocation(); if (previousToken !== contextToken) { ts.Debug.assert(!!previousToken, "Expected 'contextToken' to be defined when different from 'previousToken'."); } @@ -119546,6 +121200,9 @@ var ts; filterGlobalCompletion(symbols); } function shouldOfferImportCompletions() { + // If current completion is for non-contextual Object literal shortahands, ignore auto-import symbols + if (isNonContextualObjectLiteral) + return false; // If not already a module, must have modules enabled. if (!preferences.includeCompletionsForModuleExports) return false; @@ -119576,13 +121233,34 @@ var ts; ? 6 /* TypeAssertionKeywords */ : 7 /* TypeKeywords */; } + var variableDeclaration = getVariableDeclaration(location); ts.filterMutate(symbols, function (symbol) { if (!ts.isSourceFile(location)) { // export = /**/ here we want to get all meanings, so any symbol is ok if (ts.isExportAssignment(location.parent)) { return true; } - symbol = ts.skipAlias(symbol, typeChecker); + // Filter out variables from their own initializers + // `const a = /* no 'a' here */` + if (variableDeclaration && symbol.valueDeclaration === variableDeclaration) { + return false; + } + // External modules can have global export declarations that will be + // available as global keywords in all scopes. But if the external module + // already has an explicit export and user only wants to user explicit + // module imports then the global keywords will be filtered out so auto + // import suggestions will win in the completion + var symbolOrigin = ts.skipAlias(symbol, typeChecker); + // We only want to filter out the global keywords + // Auto Imports are not available for scripts so this conditional is always false + if (!!sourceFile.externalModuleIndicator + && !compilerOptions.allowUmdGlobalAccess + && symbolToSortTextMap[ts.getSymbolId(symbol)] === SortText.GlobalsOrKeywords + && symbolToSortTextMap[ts.getSymbolId(symbolOrigin)] === SortText.AutoImportSuggestions) { + return false; + } + // Continue with origin symbol + symbol = symbolOrigin; // import m = /**/ <-- It can only access namespace (if typing import = x. this would get member symbols and not namespace) if (ts.isInRightSideOfInternalImportEqualsDeclaration(location)) { return !!(symbol.flags & 1920 /* Namespace */); @@ -119596,6 +121274,18 @@ var ts; return !!(ts.getCombinedLocalAndExportSymbolFlags(symbol) & 111551 /* Value */); }); } + function getVariableDeclaration(property) { + var variableDeclaration = ts.findAncestor(property, function (node) { + return ts.isFunctionBlock(node) || isArrowFunctionBody(node) || ts.isBindingPattern(node) + ? "quit" + : ts.isVariableDeclaration(node); + }); + return variableDeclaration; + } + function isArrowFunctionBody(node) { + return node.parent && ts.isArrowFunction(node.parent) && node.parent.body === node; + } + ; function isTypeOnlyCompletion() { return insideJsDocTagTypeExpression || !isContextTokenValueLocation(contextToken) && @@ -119855,18 +121545,19 @@ var ts; } return false; } - function isNewIdentifierDefinitionLocation(previousToken) { - if (previousToken) { - var containingNodeKind = previousToken.parent.kind; + function isNewIdentifierDefinitionLocation() { + if (contextToken) { + var containingNodeKind = contextToken.parent.kind; // Previous token may have been a keyword that was converted to an identifier. - switch (keywordForNode(previousToken)) { + switch (keywordForNode(contextToken)) { case 27 /* CommaToken */: return containingNodeKind === 203 /* CallExpression */ // func( a, | || containingNodeKind === 166 /* Constructor */ // constructor( a, | /* public, protected, private keywords are allowed here, so show completion */ || containingNodeKind === 204 /* NewExpression */ // new C(a, | || containingNodeKind === 199 /* ArrayLiteralExpression */ // [a, | || containingNodeKind === 216 /* BinaryExpression */ // const x = (a, | - || containingNodeKind === 174 /* FunctionType */; // var x: (s: string, list| + || containingNodeKind === 174 /* FunctionType */ // var x: (s: string, list| + || containingNodeKind === 200 /* ObjectLiteralExpression */; // const obj = { x, | case 20 /* OpenParenToken */: return containingNodeKind === 203 /* CallExpression */ // func( | || containingNodeKind === 166 /* Constructor */ // constructor( | @@ -119883,7 +121574,8 @@ var ts; case 24 /* DotToken */: return containingNodeKind === 256 /* ModuleDeclaration */; // module A.| case 18 /* OpenBraceToken */: - return containingNodeKind === 252 /* ClassDeclaration */; // class A{ | + return containingNodeKind === 252 /* ClassDeclaration */ // class A { | + || containingNodeKind === 200 /* ObjectLiteralExpression */; // const obj = { | case 62 /* EqualsToken */: return containingNodeKind === 249 /* VariableDeclaration */ // const x = a| || containingNodeKind === 216 /* BinaryExpression */; // x = a| @@ -119923,13 +121615,27 @@ var ts; var existingMembers; if (objectLikeContainer.kind === 200 /* ObjectLiteralExpression */) { var instantiatedType = tryGetObjectLiteralContextualType(objectLikeContainer, typeChecker); + // Check completions for Object property value shorthand if (instantiatedType === undefined) { - return 2 /* Fail */; + if (objectLikeContainer.flags & 16777216 /* InWithStatement */) { + return 2 /* Fail */; + } + isNonContextualObjectLiteral = true; + return 0 /* Continue */; } var completionsType = typeChecker.getContextualType(objectLikeContainer, 4 /* Completions */); - isNewIdentifierLocation = ts.hasIndexSignature(completionsType || instantiatedType); + var hasStringIndexType = (completionsType || instantiatedType).getStringIndexType(); + var hasNumberIndextype = (completionsType || instantiatedType).getNumberIndexType(); + isNewIdentifierLocation = !!hasStringIndexType || !!hasNumberIndextype; typeMembers = getPropertiesForObjectExpression(instantiatedType, completionsType, objectLikeContainer, typeChecker); existingMembers = objectLikeContainer.properties; + if (typeMembers.length === 0) { + // Edge case: If NumberIndexType exists + if (!hasNumberIndextype) { + isNonContextualObjectLiteral = true; + return 0 /* Continue */; + } + } } else { ts.Debug.assert(objectLikeContainer.kind === 196 /* ObjectBindingPattern */); @@ -120267,6 +121973,7 @@ var ts; case 99 /* ImportKeyword */: case 118 /* LetKeyword */: case 84 /* ConstKeyword */: + case 135 /* InferKeyword */: case 149 /* TypeKeyword */: // type htm| return true; case 41 /* AsteriskToken */: @@ -120308,6 +122015,7 @@ var ts; return ts.isPropertyDeclaration(contextToken.parent); } return ts.isDeclarationName(contextToken) + && !ts.isShorthandPropertyAssignment(contextToken.parent) && !ts.isJsxAttribute(contextToken.parent) // Don't block completions if we're in `class C /**/`, because we're *past* the end of the identifier and might want to complete `extends`. // If `contextToken !== previousToken`, this is `class C ex/**/`. @@ -120651,6 +122359,7 @@ var ts; return ts.some(member.declarations, function (decl) { return decl.parent !== obj; }); } } + Completions.getPropertiesForObjectExpression = getPropertiesForObjectExpression; /** * Gets all properties on a type, but if that type is a union of several types, * excludes array-like types or callable/constructable types. @@ -120979,7 +122688,7 @@ var ts; case 285 /* DefaultClause */: // Container is either a class declaration or the declaration is a classDeclaration if (modifierFlag & 128 /* Abstract */ && ts.isClassDeclaration(declaration)) { - return __spreadArrays(declaration.members, [declaration]); + return __spreadArray(__spreadArray([], declaration.members), [declaration]); } else { return container.statements; @@ -120987,7 +122696,7 @@ var ts; case 166 /* Constructor */: case 165 /* MethodDeclaration */: case 251 /* FunctionDeclaration */: - return __spreadArrays(container.parameters, (ts.isClassLike(container.parent) ? container.parent.members : [])); + return __spreadArray(__spreadArray([], container.parameters), (ts.isClassLike(container.parent) ? container.parent.members : [])); case 252 /* ClassDeclaration */: case 221 /* ClassExpression */: case 253 /* InterfaceDeclaration */: @@ -120998,11 +122707,11 @@ var ts; if (modifierFlag & (28 /* AccessibilityModifier */ | 64 /* Readonly */)) { var constructor = ts.find(container.members, ts.isConstructorDeclaration); if (constructor) { - return __spreadArrays(nodes, constructor.parameters); + return __spreadArray(__spreadArray([], nodes), constructor.parameters); } } else if (modifierFlag & 128 /* Abstract */) { - return __spreadArrays(nodes, [container]); + return __spreadArray(__spreadArray([], nodes), [container]); } return nodes; // Syntactically invalid positions that the parser might produce anyway @@ -121421,6 +123130,10 @@ var ts; cancellationToken.throwIfCancellationRequested(); switch (direct.kind) { case 203 /* CallExpression */: + if (ts.isImportCall(direct)) { + handleImportCall(direct); + break; + } if (!isAvailableThroughGlobal) { var parent = direct.parent; if (exportKind === 2 /* ExportEquals */ && parent.kind === 249 /* VariableDeclaration */) { @@ -121454,7 +123167,7 @@ var ts; } else if (direct.exportClause.kind === 269 /* NamespaceExport */) { // `export * as foo from "foo"` add to indirect uses - addIndirectUsers(getSourceFileLikeForImportDeclaration(direct)); + addIndirectUser(getSourceFileLikeForImportDeclaration(direct), /** addTransitiveDependencies */ true); } else { // This is `export { foo } from "foo"` and creates an alias symbol, so recursive search will get handle re-exports. @@ -121462,6 +123175,10 @@ var ts; } break; case 195 /* ImportType */: + // Only check for typeof import('xyz') + if (direct.isTypeOf && !direct.qualifier && isExported(direct)) { + addIndirectUser(direct.getSourceFile(), /** addTransitiveDependencies */ true); + } directImports.push(direct); break; default: @@ -121470,6 +123187,18 @@ var ts; } } } + function handleImportCall(importCall) { + var top = ts.findAncestor(importCall, isAmbientModuleDeclaration) || importCall.getSourceFile(); + addIndirectUser(top, /** addTransitiveDependencies */ !!isExported(importCall, /** stopAtAmbientModule */ true)); + } + function isExported(node, stopAtAmbientModule) { + if (stopAtAmbientModule === void 0) { stopAtAmbientModule = false; } + return ts.findAncestor(node, function (node) { + if (stopAtAmbientModule && isAmbientModuleDeclaration(node)) + return "quit"; + return ts.some(node.modifiers, function (mod) { return mod.kind === 92 /* ExportKeyword */; }); + }); + } function handleNamespaceImport(importDeclaration, name, isReExport, alreadyAddedDirect) { if (exportKind === 2 /* ExportEquals */) { // This is a direct import, not import-as-namespace. @@ -121480,34 +123209,33 @@ var ts; var sourceFileLike = getSourceFileLikeForImportDeclaration(importDeclaration); ts.Debug.assert(sourceFileLike.kind === 297 /* SourceFile */ || sourceFileLike.kind === 256 /* ModuleDeclaration */); if (isReExport || findNamespaceReExports(sourceFileLike, name, checker)) { - addIndirectUsers(sourceFileLike); + addIndirectUser(sourceFileLike, /** addTransitiveDependencies */ true); } else { addIndirectUser(sourceFileLike); } } } - function addIndirectUser(sourceFileLike) { + /** Adds a module and all of its transitive dependencies as possible indirect users. */ + function addIndirectUser(sourceFileLike, addTransitiveDependencies) { + if (addTransitiveDependencies === void 0) { addTransitiveDependencies = false; } ts.Debug.assert(!isAvailableThroughGlobal); var isNew = markSeenIndirectUser(sourceFileLike); - if (isNew) { - indirectUserDeclarations.push(sourceFileLike); // TODO: GH#18217 - } - return isNew; - } - /** Adds a module and all of its transitive dependencies as possible indirect users. */ - function addIndirectUsers(sourceFileLike) { - if (!addIndirectUser(sourceFileLike)) { + if (!isNew) + return; + indirectUserDeclarations.push(sourceFileLike); // TODO: GH#18217 + if (!addTransitiveDependencies) return; - } var moduleSymbol = checker.getMergedSymbol(sourceFileLike.symbol); + if (!moduleSymbol) + return; ts.Debug.assert(!!(moduleSymbol.flags & 1536 /* Module */)); var directImports = getDirectImports(moduleSymbol); if (directImports) { for (var _i = 0, directImports_1 = directImports; _i < directImports_1.length; _i++) { var directImport = directImports_1[_i]; if (!ts.isImportTypeNode(directImport)) { - addIndirectUsers(getSourceFileLikeForImportDeclaration(directImport)); + addIndirectUser(getSourceFileLikeForImportDeclaration(directImport), /** addTransitiveDependencies */ true); } } } @@ -121959,6 +123687,7 @@ var ts; DefinitionKind[DefinitionKind["Keyword"] = 2] = "Keyword"; DefinitionKind[DefinitionKind["This"] = 3] = "This"; DefinitionKind[DefinitionKind["String"] = 4] = "String"; + DefinitionKind[DefinitionKind["TripleSlashReference"] = 5] = "TripleSlashReference"; })(DefinitionKind = FindAllReferences.DefinitionKind || (FindAllReferences.DefinitionKind = {})); var EntryKind; (function (EntryKind) { @@ -122135,10 +123864,10 @@ var ts; || node.parent.kind === 198 /* BindingElement */ || node.parent.kind === 202 /* ElementAccessExpression */ || node.kind === 105 /* SuperKeyword */) { - referenceEntries = entries && __spreadArrays(entries); + referenceEntries = entries && __spreadArray([], entries); } else { - var queue = entries && __spreadArrays(entries); + var queue = entries && __spreadArray([], entries); var seenNodes = new ts.Map(); while (queue && queue.length) { var entry = queue.shift(); @@ -122200,47 +123929,56 @@ var ts; var _a = getDefinitionKindAndDisplayParts(symbol, checker, originalNode), displayParts_1 = _a.displayParts, kind_1 = _a.kind; var name_1 = displayParts_1.map(function (p) { return p.text; }).join(""); var declaration = symbol.declarations && ts.firstOrUndefined(symbol.declarations); - return { - node: declaration ? - ts.getNameOfDeclaration(declaration) || declaration : - originalNode, - name: name_1, + var node = declaration ? (ts.getNameOfDeclaration(declaration) || declaration) : originalNode; + return __assign(__assign({}, getFileAndTextSpanFromNode(node)), { name: name_1, kind: kind_1, - displayParts: displayParts_1, - context: getContextNode(declaration) - }; + displayParts: displayParts_1, context: getContextNode(declaration) }); } case 1 /* Label */: { - var node_1 = def.node; - return { node: node_1, name: node_1.text, kind: "label" /* label */, displayParts: [ts.displayPart(node_1.text, ts.SymbolDisplayPartKind.text)] }; + var node = def.node; + return __assign(__assign({}, getFileAndTextSpanFromNode(node)), { name: node.text, kind: "label" /* label */, displayParts: [ts.displayPart(node.text, ts.SymbolDisplayPartKind.text)] }); } case 2 /* Keyword */: { - var node_2 = def.node; - var name_2 = ts.tokenToString(node_2.kind); - return { node: node_2, name: name_2, kind: "keyword" /* keyword */, displayParts: [{ text: name_2, kind: "keyword" /* keyword */ }] }; + var node = def.node; + var name_2 = ts.tokenToString(node.kind); + return __assign(__assign({}, getFileAndTextSpanFromNode(node)), { name: name_2, kind: "keyword" /* keyword */, displayParts: [{ text: name_2, kind: "keyword" /* keyword */ }] }); } case 3 /* This */: { - var node_3 = def.node; - var symbol = checker.getSymbolAtLocation(node_3); - var displayParts_2 = symbol && ts.SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, node_3.getSourceFile(), ts.getContainerNode(node_3), node_3).displayParts || [ts.textPart("this")]; - return { node: node_3, name: "this", kind: "var" /* variableElement */, displayParts: displayParts_2 }; + var node = def.node; + var symbol = checker.getSymbolAtLocation(node); + var displayParts_2 = symbol && ts.SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, node.getSourceFile(), ts.getContainerNode(node), node).displayParts || [ts.textPart("this")]; + return __assign(__assign({}, getFileAndTextSpanFromNode(node)), { name: "this", kind: "var" /* variableElement */, displayParts: displayParts_2 }); } case 4 /* String */: { - var node_4 = def.node; - return { node: node_4, name: node_4.text, kind: "var" /* variableElement */, displayParts: [ts.displayPart(ts.getTextOfNode(node_4), ts.SymbolDisplayPartKind.stringLiteral)] }; + var node = def.node; + return __assign(__assign({}, getFileAndTextSpanFromNode(node)), { name: node.text, kind: "var" /* variableElement */, displayParts: [ts.displayPart(ts.getTextOfNode(node), ts.SymbolDisplayPartKind.stringLiteral)] }); + } + case 5 /* TripleSlashReference */: { + return { + textSpan: ts.createTextSpanFromRange(def.reference), + sourceFile: def.file, + name: def.reference.fileName, + kind: "string" /* string */, + displayParts: [ts.displayPart("\"" + def.reference.fileName + "\"", ts.SymbolDisplayPartKind.stringLiteral)] + }; } default: return ts.Debug.assertNever(def); } })(); - var node = info.node, name = info.name, kind = info.kind, displayParts = info.displayParts, context = info.context; - var sourceFile = node.getSourceFile(); - var textSpan = getTextSpan(ts.isComputedPropertyName(node) ? node.expression : node, sourceFile); + var sourceFile = info.sourceFile, textSpan = info.textSpan, name = info.name, kind = info.kind, displayParts = info.displayParts, context = info.context; return __assign({ containerKind: "" /* unknown */, containerName: "", fileName: sourceFile.fileName, kind: kind, name: name, textSpan: textSpan, displayParts: displayParts }, toContextSpan(textSpan, sourceFile, context)); } + function getFileAndTextSpanFromNode(node) { + var sourceFile = node.getSourceFile(); + return { + sourceFile: sourceFile, + textSpan: getTextSpan(ts.isComputedPropertyName(node) ? node.expression : node, sourceFile) + }; + } function getDefinitionKindAndDisplayParts(symbol, checker, node) { var meaning = Core.getIntersectingMeaningFromDeclarations(node, symbol); var enclosingDeclaration = symbol.declarations && ts.firstOrUndefined(symbol.declarations) || node; @@ -122447,6 +124185,7 @@ var ts; (function (Core) { /** Core find-all-references algorithm. Handles special cases before delegating to `getReferencedSymbolsForSymbol`. */ function getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options, sourceFilesSet) { + var _a, _b; if (options === void 0) { options = {}; } if (sourceFilesSet === void 0) { sourceFilesSet = new ts.Set(sourceFiles.map(function (f) { return f.fileName; })); } if (options.use === 1 /* References */) { @@ -122456,9 +124195,22 @@ var ts; node = ts.getAdjustedRenameLocation(node); } if (ts.isSourceFile(node)) { - var reference = ts.GoToDefinition.getReferenceAtPosition(node, position, program); - var moduleSymbol = reference && program.getTypeChecker().getMergedSymbol(reference.file.symbol); - return moduleSymbol && getReferencedSymbolsForModule(program, moduleSymbol, /*excludeImportTypeOfExportEquals*/ false, sourceFiles, sourceFilesSet); + var resolvedRef = ts.GoToDefinition.getReferenceAtPosition(node, position, program); + if (!resolvedRef) { + return undefined; + } + var moduleSymbol = program.getTypeChecker().getMergedSymbol(resolvedRef.file.symbol); + if (moduleSymbol) { + return getReferencedSymbolsForModule(program, moduleSymbol, /*excludeImportTypeOfExportEquals*/ false, sourceFiles, sourceFilesSet); + } + var fileIncludeReasons = program.getFileIncludeReasons(); + if (!fileIncludeReasons) { + return undefined; + } + return [{ + definition: { type: 5 /* TripleSlashReference */, reference: resolvedRef.reference, file: node }, + references: getReferencesForNonModule(resolvedRef.file, fileIncludeReasons, program) || ts.emptyArray + }]; } if (!options.implementations) { var special = getReferencedSymbolsSpecial(node, sourceFiles, cancellationToken); @@ -122467,11 +124219,26 @@ var ts; } } var checker = program.getTypeChecker(); - var symbol = checker.getSymbolAtLocation(node); + // constructors should use the class symbol, detected by name, if present + var symbol = checker.getSymbolAtLocation(ts.isConstructorDeclaration(node) && node.parent.name || node); // Could not find a symbol e.g. unknown identifier if (!symbol) { // String literal might be a property (and thus have a symbol), so do this here rather than in getReferencedSymbolsSpecial. - return !options.implementations && ts.isStringLiteral(node) ? getReferencesForStringLiteral(node, sourceFiles, cancellationToken) : undefined; + if (!options.implementations && ts.isStringLiteralLike(node)) { + if (ts.isRequireCall(node.parent, /*requireStringLiteralLikeArgument*/ true) || ts.isExternalModuleReference(node.parent) || ts.isImportDeclaration(node.parent) || ts.isImportCall(node.parent)) { + var fileIncludeReasons = program.getFileIncludeReasons(); + var referencedFileName = (_b = (_a = node.getSourceFile().resolvedModules) === null || _a === void 0 ? void 0 : _a.get(node.text)) === null || _b === void 0 ? void 0 : _b.resolvedFileName; + var referencedFile = referencedFileName ? program.getSourceFile(referencedFileName) : undefined; + if (referencedFile) { + return [{ definition: { type: 4 /* String */, node: node }, references: getReferencesForNonModule(referencedFile, fileIncludeReasons, program) || ts.emptyArray }]; + } + // Fall through to string literal references. This is not very likely to return + // anything useful, but I guess it's better than nothing, and there's an existing + // test that expects this to happen (fourslash/cases/untypedModuleImport.ts). + } + return getReferencesForStringLiteral(node, sourceFiles, checker, cancellationToken); + } + return undefined; } if (symbol.escapedName === "export=" /* ExportEquals */) { return getReferencedSymbolsForModule(program, symbol.parent, /*excludeImportTypeOfExportEquals*/ false, sourceFiles, sourceFilesSet); @@ -122487,6 +124254,37 @@ var ts; return mergeReferences(program, moduleReferences, references, moduleReferencesOfExportTarget); } Core.getReferencedSymbolsForNode = getReferencedSymbolsForNode; + function getReferencesForFileName(fileName, program, sourceFiles, sourceFilesSet) { + var _a, _b; + if (sourceFilesSet === void 0) { sourceFilesSet = new ts.Set(sourceFiles.map(function (f) { return f.fileName; })); } + var moduleSymbol = (_a = program.getSourceFile(fileName)) === null || _a === void 0 ? void 0 : _a.symbol; + if (moduleSymbol) { + return ((_b = getReferencedSymbolsForModule(program, moduleSymbol, /*excludeImportTypeOfExportEquals*/ false, sourceFiles, sourceFilesSet)[0]) === null || _b === void 0 ? void 0 : _b.references) || ts.emptyArray; + } + var fileIncludeReasons = program.getFileIncludeReasons(); + var referencedFile = program.getSourceFile(fileName); + return referencedFile && fileIncludeReasons && getReferencesForNonModule(referencedFile, fileIncludeReasons, program) || ts.emptyArray; + } + Core.getReferencesForFileName = getReferencesForFileName; + function getReferencesForNonModule(referencedFile, refFileMap, program) { + var entries; + var references = refFileMap.get(referencedFile.path) || ts.emptyArray; + for (var _i = 0, references_1 = references; _i < references_1.length; _i++) { + var ref = references_1[_i]; + if (ts.isReferencedFile(ref)) { + var referencingFile = program.getSourceFileByPath(ref.file); + var location = ts.getReferencedFileLocation(program.getSourceFileByPath, ref); + if (ts.isReferenceFileLocation(location)) { + entries = ts.append(entries, { + kind: 0 /* Span */, + fileName: referencingFile.fileName, + textSpan: ts.createTextSpanFromRange(location) + }); + } + } + } + return entries; + } function getMergedAliasedSymbolOfNamespaceExportDeclaration(node, symbol, checker) { if (node.parent && ts.isNamespaceExportDeclaration(node.parent)) { var aliasedSymbol = checker.getAliasedSymbol(symbol); @@ -122558,8 +124356,8 @@ var ts; }) }; }; - for (var _b = 0, references_1 = references; _b < references_1.length; _b++) { - var entry = references_1[_b]; + for (var _b = 0, references_2 = references; _b < references_2.length; _b++) { + var entry = references_2[_b]; _loop_3(entry); } } @@ -122708,6 +124506,7 @@ var ts; } function getSpecialSearchKind(node) { switch (node.kind) { + case 166 /* Constructor */: case 132 /* ConstructorKeyword */: return 1 /* Constructor */; case 78 /* Identifier */: @@ -122992,8 +124791,13 @@ var ts; // within this scope is visible outside the file return undefined; } - // The search scope is the container node scope = container; + if (ts.isFunctionExpression(scope)) { + var next = void 0; + while (next = ts.getNextJSDocCommentLocation(scope)) { + scope = next; + } + } } // If symbol.parent, this means we are in an export of an external module. (Otherwise we would have returned `undefined` above.) // For an export of a module, we may be in a declaration file, and it may be accessed elsewhere. E.g.: @@ -123030,9 +124834,9 @@ var ts; } } Core.eachSymbolReferenceInFile = eachSymbolReferenceInFile; - function eachSignatureCall(signature, sourceFiles, checker, cb) { + function someSignatureUsage(signature, sourceFiles, checker, cb) { if (!signature.name || !ts.isIdentifier(signature.name)) - return; + return false; var symbol = ts.Debug.checkDefined(checker.getSymbolAtLocation(signature.name)); for (var _i = 0, sourceFiles_3 = sourceFiles; _i < sourceFiles_3.length; _i++) { var sourceFile = sourceFiles_3[_i]; @@ -123041,17 +124845,18 @@ var ts; if (!ts.isIdentifier(name) || name === signature.name || name.escapedText !== signature.name.escapedText) continue; var called = ts.climbPastPropertyAccess(name); - var call = called.parent; - if (!ts.isCallExpression(call) || call.expression !== called) - continue; + var call = ts.isCallExpression(called.parent) && called.parent.expression === called ? called.parent : undefined; var referenceSymbol = checker.getSymbolAtLocation(name); if (referenceSymbol && checker.getRootSymbols(referenceSymbol).some(function (s) { return s === symbol; })) { - cb(call); + if (cb(name, call)) { + return true; + } } } } + return false; } - Core.eachSignatureCall = eachSignatureCall; + Core.someSignatureUsage = someSignatureUsage; function getPossibleSymbolReferenceNodes(sourceFile, symbolName, container) { if (container === void 0) { container = sourceFile; } return getPossibleSymbolReferencePositions(sourceFile, symbolName, container).map(function (pos) { return ts.getTouchingPropertyName(sourceFile, pos); }); @@ -123618,11 +125423,22 @@ var ts; references: references }]; } - function getReferencesForStringLiteral(node, sourceFiles, cancellationToken) { + function getReferencesForStringLiteral(node, sourceFiles, checker, cancellationToken) { + var type = ts.getContextualTypeOrAncestorTypeNodeType(node, checker); var references = ts.flatMap(sourceFiles, function (sourceFile) { cancellationToken.throwIfCancellationRequested(); return ts.mapDefined(getPossibleSymbolReferenceNodes(sourceFile, node.text), function (ref) { - return ts.isStringLiteral(ref) && ref.text === node.text ? nodeEntry(ref, 2 /* StringLiteral */) : undefined; + if (ts.isStringLiteralLike(ref) && ref.text === node.text) { + if (type) { + var refType = ts.getContextualTypeOrAncestorTypeNodeType(ref, checker); + if (type !== checker.getStringType() && type === refType) { + return nodeEntry(ref, 2 /* StringLiteral */); + } + } + else { + return nodeEntry(ref, 2 /* StringLiteral */); + } + } }); }); return [{ @@ -123747,7 +125563,7 @@ var ts; return cbSymbol(sym, rootSymbol, /*baseSymbol*/ undefined, kind) // Add symbol of properties/methods of the same name in base classes and implemented interfaces definitions || (rootSymbol.parent && rootSymbol.parent.flags & (32 /* Class */ | 64 /* Interface */) && allowBaseTypes(rootSymbol) - ? ts.getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.name, checker, function (base) { return cbSymbol(sym, rootSymbol, base, kind); }) + ? getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.name, checker, function (base) { return cbSymbol(sym, rootSymbol, base, kind); }) : undefined); }); } @@ -123758,6 +125574,32 @@ var ts; } } } + /** + * Find symbol of the given property-name and add the symbol to the given result array + * @param symbol a symbol to start searching for the given propertyName + * @param propertyName a name of property to search for + * @param result an array of symbol of found property symbols + * @param previousIterationSymbolsCache a cache of symbol from previous iterations of calling this function to prevent infinite revisiting of the same symbol. + * The value of previousIterationSymbol is undefined when the function is first called. + */ + function getPropertySymbolsFromBaseTypes(symbol, propertyName, checker, cb) { + var seen = new ts.Map(); + return recur(symbol); + function recur(symbol) { + // Use `addToSeen` to ensure we don't infinitely recurse in this situation: + // interface C extends C { + // /*findRef*/propName: string; + // } + if (!(symbol.flags & (32 /* Class */ | 64 /* Interface */)) || !ts.addToSeen(seen, ts.getSymbolId(symbol))) + return; + return ts.firstDefined(symbol.declarations, function (declaration) { return ts.firstDefined(ts.getAllSuperTypeNodes(declaration), function (typeReference) { + var type = checker.getTypeAtLocation(typeReference); + var propertySymbol = type && type.symbol && checker.getPropertyOfType(type, propertyName); + // Visit the typeReference as well to see if it directly or indirectly uses that property + return type && propertySymbol && (ts.firstDefined(checker.getRootSymbols(propertySymbol), cb) || recur(type.symbol)); + }); }); + } + } function isStatic(symbol) { if (!symbol.valueDeclaration) { return false; @@ -124462,7 +126304,7 @@ var ts; var toImport = oldFromNew !== undefined // If we're at the new location (file was already renamed), need to redo module resolution starting from the old location. // TODO:GH#18217 - ? getSourceFileToImportFromResolved(ts.resolveModuleName(importLiteral.text, oldImportFromPath, program.getCompilerOptions(), host), oldToNew, allFiles) + ? getSourceFileToImportFromResolved(importLiteral, ts.resolveModuleName(importLiteral.text, oldImportFromPath, program.getCompilerOptions(), host), oldToNew, allFiles) : getSourceFileToImport(importedModuleSymbol, importLiteral, sourceFile, program, host, oldToNew); // Need an update if the imported file moved, or the importing file moved and was using a relative path. return toImport !== undefined && (toImport.updated || (importingSourceFileMoved && ts.pathIsRelative(importLiteral.text))) @@ -124492,10 +126334,10 @@ var ts; var resolved = host.resolveModuleNames ? host.getResolvedModuleWithFailedLookupLocationsFromCache && host.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName) : program.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName); - return getSourceFileToImportFromResolved(resolved, oldToNew, program.getSourceFiles()); + return getSourceFileToImportFromResolved(importLiteral, resolved, oldToNew, program.getSourceFiles()); } } - function getSourceFileToImportFromResolved(resolved, oldToNew, sourceFiles) { + function getSourceFileToImportFromResolved(importLiteral, resolved, oldToNew, sourceFiles) { // Search through all locations looking for a moved file, and only then test already existing files. // This is because if `a.ts` is compiled to `a.js` and `a.ts` is moved, we don't want to resolve anything to `a.js`, but to `a.ts`'s new location. if (!resolved) @@ -124508,8 +126350,9 @@ var ts; } // Then failed lookups that are in the list of sources var result = ts.forEach(resolved.failedLookupLocations, tryChangeWithIgnoringPackageJsonExisting) - // Then failed lookups except package.json since we dont want to touch them (only included ts/js files) - || ts.forEach(resolved.failedLookupLocations, tryChangeWithIgnoringPackageJson); + // Then failed lookups except package.json since we dont want to touch them (only included ts/js files). + // At this point, the confidence level of this fix being correct is too low to change bare specifiers or absolute paths. + || ts.pathIsRelative(importLiteral.text) && ts.forEach(resolved.failedLookupLocations, tryChangeWithIgnoringPackageJson); if (result) return result; // If nothing changed, then result is resolved module file thats not updated @@ -124561,9 +126404,9 @@ var ts; var GoToDefinition; (function (GoToDefinition) { function getDefinitionAtPosition(program, sourceFile, position) { - var reference = getReferenceAtPosition(sourceFile, position, program); - if (reference) { - return [getDefinitionInfoForFileReference(reference.fileName, reference.file.fileName)]; + var resolvedRef = getReferenceAtPosition(sourceFile, position, program); + if (resolvedRef) { + return [getDefinitionInfoForFileReference(resolvedRef.reference.fileName, resolvedRef.file.fileName)]; } var node = ts.getTouchingPropertyName(sourceFile, position); if (node === sourceFile) { @@ -124594,7 +126437,7 @@ var ts; else { var defs = getDefinitionFromSymbol(typeChecker, symbol, node, calledDeclaration) || ts.emptyArray; // For a 'super()' call, put the signature first, else put the variable first. - return node.kind === 105 /* SuperKeyword */ ? __spreadArrays([sigInfo], defs) : __spreadArrays(defs, [sigInfo]); + return node.kind === 105 /* SuperKeyword */ ? __spreadArray([sigInfo], defs) : __spreadArray(__spreadArray([], defs), [sigInfo]); } } // Because name in short-hand property assignment has two different meanings: property name and property value, @@ -124647,11 +126490,6 @@ var ts; return getDefinitionFromSymbol(typeChecker, symbol, node); } GoToDefinition.getDefinitionAtPosition = getDefinitionAtPosition; - function isShorthandPropertyAssignmentOfModuleExports(symbol) { - var shorthandProperty = ts.tryCast(symbol.valueDeclaration, ts.isShorthandPropertyAssignment); - var binaryExpression = ts.tryCast(shorthandProperty === null || shorthandProperty === void 0 ? void 0 : shorthandProperty.parent.parent, ts.isAssignmentExpression); - return !!binaryExpression && ts.getAssignmentDeclarationKind(binaryExpression) === 2 /* ModuleExports */; - } /** * True if we should not add definitions for both the signature symbol and the definition symbol. * True for `const |f = |() => 0`, false for `function |f() {} const |g = f;`. @@ -124667,18 +126505,18 @@ var ts; var referencePath = findReferenceInPosition(sourceFile.referencedFiles, position); if (referencePath) { var file = program.getSourceFileFromReference(sourceFile, referencePath); - return file && { fileName: referencePath.fileName, file: file }; + return file && { reference: referencePath, file: file }; } var typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position); if (typeReferenceDirective) { var reference = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName); var file = reference && program.getSourceFile(reference.resolvedFileName); // TODO:GH#18217 - return file && { fileName: typeReferenceDirective.fileName, file: file }; + return file && { reference: typeReferenceDirective, file: file }; } var libReferenceDirective = findReferenceInPosition(sourceFile.libReferenceDirectives, position); if (libReferenceDirective) { var file = program.getLibFileFromReference(libReferenceDirective); - return file && { fileName: libReferenceDirective.fileName, file: file }; + return file && { reference: libReferenceDirective, file: file }; } return undefined; } @@ -124749,24 +126587,10 @@ var ts; // get the aliased symbol instead. This allows for goto def on an import e.g. // import {A, B} from "mod"; // to jump to the implementation directly. - while (symbol) { - if (symbol.flags & 2097152 /* Alias */ && shouldSkipAlias(node, symbol.declarations[0])) { - var aliased = checker.getAliasedSymbol(symbol); - if (!aliased.declarations) { - break; - } - symbol = aliased; - } - else if (isShorthandPropertyAssignmentOfModuleExports(symbol)) { - // Skip past `module.exports = { Foo }` even though 'Foo' is not a real alias - var shorthandTarget = checker.resolveName(symbol.name, symbol.valueDeclaration, 111551 /* Value */, /*excludeGlobals*/ false); - if (!ts.some(shorthandTarget === null || shorthandTarget === void 0 ? void 0 : shorthandTarget.declarations)) { - break; - } - symbol = shorthandTarget; - } - else { - break; + if (symbol && symbol.flags & 2097152 /* Alias */ && shouldSkipAlias(node, symbol.declarations[0])) { + var aliased = checker.getAliasedSymbol(symbol); + if (aliased.declarations) { + return aliased; } } return symbol; @@ -124859,7 +126683,7 @@ var ts; kind: "script" /* scriptElement */, name: name, containerName: undefined, - containerKind: undefined, + containerKind: undefined, // TODO: GH#18217 }; } /** Returns a CallLikeExpression where `node` is the target being invoked. */ @@ -125137,7 +126961,7 @@ var ts; * @param position The (character-indexed) position in the file where the check should * be performed. */ - function getDocCommentTemplateAtPosition(newLine, sourceFile, position) { + function getDocCommentTemplateAtPosition(newLine, sourceFile, position, options) { var tokenAtPos = ts.getTokenAtPosition(sourceFile, position); var existingDocComment = ts.findAncestor(tokenAtPos, ts.isJSDoc); if (existingDocComment && (existingDocComment.comment !== undefined || ts.length(existingDocComment.tags))) { @@ -125149,33 +126973,35 @@ var ts; if (!existingDocComment && tokenStart < position) { return undefined; } - var commentOwnerInfo = getCommentOwnerInfo(tokenAtPos); + var commentOwnerInfo = getCommentOwnerInfo(tokenAtPos, options); if (!commentOwnerInfo) { return undefined; } - var commentOwner = commentOwnerInfo.commentOwner, parameters = commentOwnerInfo.parameters; + var commentOwner = commentOwnerInfo.commentOwner, parameters = commentOwnerInfo.parameters, hasReturn = commentOwnerInfo.hasReturn; if (commentOwner.getStart(sourceFile) < position) { return undefined; } - if (!parameters || parameters.length === 0) { - // if there are no parameters, just complete to a single line JSDoc comment - var singleLineResult = "/** */"; - return { newText: singleLineResult, caretOffset: 3 }; - } var indentationStr = getIndentationStringAtPosition(sourceFile, position); + var isJavaScriptFile = ts.hasJSFileExtension(sourceFile.fileName); + var tags = (parameters ? parameterDocComments(parameters || [], isJavaScriptFile, indentationStr, newLine) : "") + + (hasReturn ? returnsDocComment(indentationStr, newLine) : ""); // A doc comment consists of the following // * The opening comment line // * the first line (without a param) for the object's untagged info (this is also where the caret ends up) // * the '@param'-tagged lines + // * the '@returns'-tag // * TODO: other tags. // * the closing comment line // * if the caret was directly in front of the object, then we add an extra line and indentation. - var preamble = "/**" + newLine + indentationStr + " * "; - var result = preamble + newLine + - parameterDocComments(parameters, ts.hasJSFileExtension(sourceFile.fileName), indentationStr, newLine) + - indentationStr + " */" + - (tokenStart === position ? newLine + indentationStr : ""); - return { newText: result, caretOffset: preamble.length }; + var openComment = "/**"; + var closeComment = " */"; + if (tags) { + var preamble = openComment + newLine + indentationStr + " * "; + var endLine = tokenStart === position ? newLine + indentationStr : ""; + var result = preamble + newLine + tags + indentationStr + closeComment + endLine; + return { newText: result, caretOffset: preamble.length }; + } + return { newText: openComment + closeComment, caretOffset: 3 }; } JsDoc.getDocCommentTemplateAtPosition = getDocCommentTemplateAtPosition; function getIndentationStringAtPosition(sourceFile, position) { @@ -125194,10 +127020,13 @@ var ts; return indentationStr + " * @param " + type + paramName + newLine; }).join(""); } - function getCommentOwnerInfo(tokenAtPos) { - return ts.forEachAncestor(tokenAtPos, getCommentOwnerInfoWorker); + function returnsDocComment(indentationStr, newLine) { + return indentationStr + " * @returns" + newLine; + } + function getCommentOwnerInfo(tokenAtPos, options) { + return ts.forEachAncestor(tokenAtPos, function (n) { return getCommentOwnerInfoWorker(n, options); }); } - function getCommentOwnerInfoWorker(commentOwner) { + function getCommentOwnerInfoWorker(commentOwner, options) { switch (commentOwner.kind) { case 251 /* FunctionDeclaration */: case 208 /* FunctionExpression */: @@ -125205,10 +127034,10 @@ var ts; case 166 /* Constructor */: case 164 /* MethodSignature */: case 209 /* ArrowFunction */: - var parameters = commentOwner.parameters; - return { commentOwner: commentOwner, parameters: parameters }; + var host = commentOwner; + return { commentOwner: commentOwner, parameters: host.parameters, hasReturn: hasReturn(host, options) }; case 288 /* PropertyAssignment */: - return getCommentOwnerInfoWorker(commentOwner.initializer); + return getCommentOwnerInfoWorker(commentOwner.initializer, options); case 252 /* ClassDeclaration */: case 253 /* InterfaceDeclaration */: case 162 /* PropertySignature */: @@ -125219,10 +127048,12 @@ var ts; case 232 /* VariableStatement */: { var varStatement = commentOwner; var varDeclarations = varStatement.declarationList.declarations; - var parameters_1 = varDeclarations.length === 1 && varDeclarations[0].initializer - ? getParametersFromRightHandSideOfAssignment(varDeclarations[0].initializer) + var host_1 = varDeclarations.length === 1 && varDeclarations[0].initializer + ? getRightHandSideOfAssignment(varDeclarations[0].initializer) : undefined; - return { commentOwner: commentOwner, parameters: parameters_1 }; + return host_1 + ? { commentOwner: commentOwner, parameters: host_1.parameters, hasReturn: hasReturn(host_1, options) } + : { commentOwner: commentOwner }; } case 297 /* SourceFile */: return "quit"; @@ -125232,44 +127063,39 @@ var ts; // want to give back a JSDoc template for the 'b' or 'c' in 'namespace a.b.c { }'. return commentOwner.parent.kind === 256 /* ModuleDeclaration */ ? undefined : { commentOwner: commentOwner }; case 233 /* ExpressionStatement */: - return getCommentOwnerInfoWorker(commentOwner.expression); + return getCommentOwnerInfoWorker(commentOwner.expression, options); case 216 /* BinaryExpression */: { var be = commentOwner; if (ts.getAssignmentDeclarationKind(be) === 0 /* None */) { return "quit"; } - var parameters_2 = ts.isFunctionLike(be.right) ? be.right.parameters : ts.emptyArray; - return { commentOwner: commentOwner, parameters: parameters_2 }; + return ts.isFunctionLike(be.right) + ? { commentOwner: commentOwner, parameters: be.right.parameters, hasReturn: hasReturn(be.right, options) } + : { commentOwner: commentOwner }; } case 163 /* PropertyDeclaration */: var init = commentOwner.initializer; if (init && (ts.isFunctionExpression(init) || ts.isArrowFunction(init))) { - return { commentOwner: commentOwner, parameters: init.parameters }; + return { commentOwner: commentOwner, parameters: init.parameters, hasReturn: hasReturn(init, options) }; } } } - /** - * Digs into an an initializer or RHS operand of an assignment operation - * to get the parameters of an apt signature corresponding to a - * function expression or a class expression. - * - * @param rightHandSide the expression which may contain an appropriate set of parameters - * @returns the parameters of a signature found on the RHS if one exists; otherwise 'emptyArray'. - */ - function getParametersFromRightHandSideOfAssignment(rightHandSide) { + function hasReturn(node, options) { + return !!(options === null || options === void 0 ? void 0 : options.generateReturnInDocTemplate) && + (ts.isArrowFunction(node) && ts.isExpression(node.body) + || ts.isFunctionLikeDeclaration(node) && node.body && ts.isBlock(node.body) && !!ts.forEachReturnStatement(node.body, function (n) { return n; })); + } + function getRightHandSideOfAssignment(rightHandSide) { while (rightHandSide.kind === 207 /* ParenthesizedExpression */) { rightHandSide = rightHandSide.expression; } switch (rightHandSide.kind) { case 208 /* FunctionExpression */: case 209 /* ArrowFunction */: - return rightHandSide.parameters; - case 221 /* ClassExpression */: { - var ctr = ts.find(rightHandSide.members, ts.isConstructorDeclaration); - return ctr ? ctr.parameters : ts.emptyArray; - } + return rightHandSide; + case 221 /* ClassExpression */: + return ts.find(rightHandSide.members, ts.isConstructorDeclaration); } - return ts.emptyArray; } })(JsDoc = ts.JsDoc || (ts.JsDoc = {})); })(ts || (ts = {})); @@ -125389,7 +127215,7 @@ var ts; textSpan: ts.createTextSpanFromNode(declaration), // TODO(jfreeman): What should be the containerName when the container has a computed name? containerName: containerName ? containerName.text : "", - containerKind: containerName ? ts.getNodeKind(container) : "" /* unknown */, + containerKind: containerName ? ts.getNodeKind(container) : "" /* unknown */, // TODO: GH#18217 Just use `container ? ...` }; } })(NavigateTo = ts.NavigateTo || (ts.NavigateTo = {})); @@ -125555,6 +127381,16 @@ var ts; addChildrenRecursively(child); endNode(); } + function addNodeWithRecursiveInitializer(node) { + if (node.initializer && isFunctionOrClassExpression(node.initializer)) { + startNode(node); + ts.forEachChild(node.initializer, addChildrenRecursively); + endNode(); + } + else { + addNodeWithRecursiveChild(node, node.initializer); + } + } /** Look for navigation bar items in node's subtree, adding them to the current `parent`. */ function addChildrenRecursively(node) { var _a; @@ -125584,6 +127420,10 @@ var ts; } break; case 163 /* PropertyDeclaration */: + if (!ts.hasDynamicName(node)) { + addNodeWithRecursiveInitializer(node); + } + break; case 162 /* PropertySignature */: if (!ts.hasDynamicName(node)) { addLeafNode(node); @@ -125622,21 +127462,16 @@ var ts; break; case 198 /* BindingElement */: case 288 /* PropertyAssignment */: - case 249 /* VariableDeclaration */: - var _e = node, name = _e.name, initializer = _e.initializer; - if (ts.isBindingPattern(name)) { - addChildrenRecursively(name); - } - else if (initializer && isFunctionOrClassExpression(initializer)) { - // Add a node for the VariableDeclaration, but not for the initializer. - startNode(node); - ts.forEachChild(initializer, addChildrenRecursively); - endNode(); + case 249 /* VariableDeclaration */: { + var child = node; + if (ts.isBindingPattern(child.name)) { + addChildrenRecursively(child.name); } else { - addNodeWithRecursiveChild(node, initializer); + addNodeWithRecursiveInitializer(child); } break; + } case 251 /* FunctionDeclaration */: var nameNode = node.name; // If we see a function declaration track as a possible ES5 class @@ -125651,8 +127486,8 @@ var ts; break; case 255 /* EnumDeclaration */: startNode(node); - for (var _f = 0, _g = node.members; _f < _g.length; _f++) { - var member = _g[_f]; + for (var _e = 0, _f = node.members; _e < _f.length; _e++) { + var member = _f[_e]; if (!isComputedProperty(member)) { addLeafNode(member); } @@ -125663,8 +127498,8 @@ var ts; case 221 /* ClassExpression */: case 253 /* InterfaceDeclaration */: startNode(node); - for (var _h = 0, _j = node.members; _h < _j.length; _h++) { - var member = _j[_h]; + for (var _g = 0, _h = node.members; _g < _h.length; _g++) { + var member = _h[_g]; addChildrenRecursively(member); } endNode(); @@ -125747,7 +127582,7 @@ var ts; defineCall.arguments[0] : defineCall.arguments[0].expression; var memberName = defineCall.arguments[1]; - var _k = startNestedNodes(node, className), depth = _k[0], classNameIdentifier = _k[1]; + var _j = startNestedNodes(node, className), depth = _j[0], classNameIdentifier = _j[1]; startNode(node, classNameIdentifier); startNode(node, ts.setTextRange(ts.factory.createIdentifier(memberName.text), memberName)); addChildrenRecursively(node.arguments[2]); @@ -125857,10 +127692,10 @@ var ts; if ((isEs5ClassMember[bAssignmentDeclarationKind] && isEs5ClassMember[aAssignmentDeclarationKind]) // merge two class elements || (isPossibleConstructor(a.node) && isEs5ClassMember[bAssignmentDeclarationKind]) // ctor function & member || (isPossibleConstructor(b.node) && isEs5ClassMember[aAssignmentDeclarationKind]) // member & ctor function - || (ts.isClassDeclaration(a.node) && isEs5ClassMember[bAssignmentDeclarationKind]) // class (generated) & member + || (ts.isClassDeclaration(a.node) && isSynthesized(a.node) && isEs5ClassMember[bAssignmentDeclarationKind]) // class (generated) & member || (ts.isClassDeclaration(b.node) && isEs5ClassMember[aAssignmentDeclarationKind]) // member & class (generated) - || (ts.isClassDeclaration(a.node) && isPossibleConstructor(b.node)) // class (generated) & ctor - || (ts.isClassDeclaration(b.node) && isPossibleConstructor(a.node)) // ctor & class (generated) + || (ts.isClassDeclaration(a.node) && isSynthesized(a.node) && isPossibleConstructor(b.node)) // class (generated) & ctor + || (ts.isClassDeclaration(b.node) && isPossibleConstructor(a.node) && isSynthesized(a.node)) // ctor & class (generated) ) { var lastANode = a.additionalNodes && ts.lastOrUndefined(a.additionalNodes) || a.node; if ((!ts.isClassDeclaration(a.node) && !ts.isClassDeclaration(b.node)) // If neither outline node is a class @@ -125874,11 +127709,11 @@ var ts; var ctor = emptyNavigationBarNode(ctorNode); ctor.indent = a.indent + 1; ctor.children = a.node === ctorFunction ? a.children : b.children; - a.children = a.node === ctorFunction ? ts.concatenate([ctor], b.children || [b]) : ts.concatenate(a.children || [a], [ctor]); + a.children = a.node === ctorFunction ? ts.concatenate([ctor], b.children || [b]) : ts.concatenate(a.children || [__assign({}, a)], [ctor]); } else { if (a.children || b.children) { - a.children = ts.concatenate(a.children || [a], b.children || [b]); + a.children = ts.concatenate(a.children || [__assign({}, a)], b.children || [b]); if (a.children) { mergeChildren(a.children, a); sortChildren(a.children); @@ -125948,6 +127783,9 @@ var ts; return true; } } + function isSynthesized(node) { + return !!(node.flags & 8 /* Synthesized */); + } // We want to merge own children like `I` in in `module A { interface I {} } module A { interface I {} }` // We don't want to merge unrelated children like `m` in `const o = { a: { m() {} }, b: { m() {} } };` function isOwnChild(n, parent) { @@ -126034,7 +127872,7 @@ var ts; return "default"; } // We may get a string with newlines or other whitespace in the case of an object dereference - // (eg: "app\n.onactivated"), so we should remove the whitespace for readabiltiy in the + // (eg: "app\n.onactivated"), so we should remove the whitespace for readability in the // navigation bar. return getFunctionOrClassName(node); case 166 /* Constructor */: @@ -126328,6 +128166,7 @@ var ts; function removeUnusedImports(oldImports, sourceFile, program) { var typeChecker = program.getTypeChecker(); var jsxNamespace = typeChecker.getJsxNamespace(sourceFile); + var jsxFragmentFactory = typeChecker.getJsxFragmentFactory(sourceFile); var jsxElementsPresent = !!(sourceFile.transformFlags & 2 /* ContainsJsx */); var usedImports = []; for (var _i = 0, oldImports_1 = oldImports; _i < oldImports_1.length; _i++) { @@ -126381,7 +128220,8 @@ var ts; return usedImports; function isDeclarationUsed(identifier) { // The JSX factory symbol is always used if JSX elements are present - even if they are not allowed. - return jsxElementsPresent && (identifier.text === jsxNamespace) || ts.FindAllReferences.Core.isSymbolReferencedInFile(identifier, typeChecker, sourceFile); + return jsxElementsPresent && (identifier.text === jsxNamespace || jsxFragmentFactory && identifier.text === jsxFragmentFactory) || + ts.FindAllReferences.Core.isSymbolReferencedInFile(identifier, typeChecker, sourceFile); } } function hasModuleDeclarationMatchingSpecifier(sourceFile, moduleSpecifier) { @@ -126671,7 +128511,7 @@ var ts; var depthRemaining = 40; var current = 0; // Includes the EOF Token so that comments which aren't attached to statements are included - var statements = __spreadArrays(sourceFile.statements, [sourceFile.endOfFileToken]); + var statements = __spreadArray(__spreadArray([], sourceFile.statements), [sourceFile.endOfFileToken]); var n = statements.length; while (current < n) { while (current < n && !ts.isAnyImportSyntax(statements[current])) { @@ -127813,7 +129653,13 @@ var ts; function getRenameInfoForNode(node, typeChecker, sourceFile, isDefinedInLibraryFile, options) { var symbol = typeChecker.getSymbolAtLocation(node); if (!symbol) { - if (ts.isLabelName(node)) { + if (ts.isStringLiteralLike(node)) { + var type = ts.getContextualTypeOrAncestorTypeNodeType(node, typeChecker); + if (type && ((type.flags & 128 /* StringLiteral */) || ((type.flags & 1048576 /* Union */) && ts.every(type.types, function (type) { return !!(type.flags & 128 /* StringLiteral */); })))) { + return getRenameInfoSuccess(node.text, node.text, "string" /* string */, "", node, sourceFile); + } + } + else if (ts.isLabelName(node)) { var name = ts.getTextOfNode(node); return getRenameInfoSuccess(name, name, "label" /* label */, "" /* none */, node, sourceFile); } @@ -127840,7 +129686,7 @@ var ts; : undefined; var displayName = specifierName || typeChecker.symbolToString(symbol); var fullDisplayName = specifierName || typeChecker.getFullyQualifiedName(symbol); - return getRenameInfoSuccess(displayName, fullDisplayName, kind, ts.SymbolDisplay.getSymbolModifiers(symbol), node, sourceFile); + return getRenameInfoSuccess(displayName, fullDisplayName, kind, ts.SymbolDisplay.getSymbolModifiers(typeChecker, symbol), node, sourceFile); } function getRenameInfoForModule(node, sourceFile, moduleSymbol) { if (!ts.isExternalModuleNameRelative(node.text)) { @@ -128668,7 +130514,19 @@ var ts; itemsSeen += item.length; } ts.Debug.assert(selectedItemIndex !== -1); // If candidates is non-empty it should always include bestSignature. We check for an empty candidates before calling this function. - return { items: ts.flatMapToMutable(items, ts.identity), applicableSpan: applicableSpan, selectedItemIndex: selectedItemIndex, argumentIndex: argumentIndex, argumentCount: argumentCount }; + var help = { items: ts.flatMapToMutable(items, ts.identity), applicableSpan: applicableSpan, selectedItemIndex: selectedItemIndex, argumentIndex: argumentIndex, argumentCount: argumentCount }; + var selected = help.items[selectedItemIndex]; + if (selected.isVariadic) { + var firstRest = ts.findIndex(selected.parameters, function (p) { return !!p.isRest; }); + if (-1 < firstRest && firstRest < selected.parameters.length - 1) { + // We don't have any code to get this correct; instead, don't highlight a current parameter AT ALL + help.argumentIndex = selected.parameters.length; + } + else { + help.argumentIndex = Math.min(help.argumentIndex, selected.parameters.length - 1); + } + } + return help; } function createTypeHelpItems(symbol, _a, sourceFile, checker) { var argumentCount = _a.argumentCount, applicableSpan = _a.argumentsSpan, invocation = _a.invocation, argumentIndex = _a.argumentIndex; @@ -128684,7 +130542,7 @@ var ts; var parameters = typeParameters.map(function (t) { return createSignatureHelpParameterForTypeParameter(t, checker, enclosingDeclaration, sourceFile, printer); }); var documentation = symbol.getDocumentationComment(checker); var tags = symbol.getJsDocTags(); - var prefixDisplayParts = __spreadArrays(typeSymbolDisplay, [ts.punctuationPart(29 /* LessThanToken */)]); + var prefixDisplayParts = __spreadArray(__spreadArray([], typeSymbolDisplay), [ts.punctuationPart(29 /* LessThanToken */)]); return { isVariadic: false, prefixDisplayParts: prefixDisplayParts, suffixDisplayParts: [ts.punctuationPart(31 /* GreaterThanToken */)], separatorDisplayParts: separatorDisplayParts, parameters: parameters, documentation: documentation, tags: tags }; } var separatorDisplayParts = [ts.punctuationPart(27 /* CommaToken */), ts.spacePart()]; @@ -128692,8 +130550,8 @@ var ts; var infos = (isTypeParameterList ? itemInfoForTypeParameters : itemInfoForParameters)(candidateSignature, checker, enclosingDeclaration, sourceFile); return ts.map(infos, function (_a) { var isVariadic = _a.isVariadic, parameters = _a.parameters, prefix = _a.prefix, suffix = _a.suffix; - var prefixDisplayParts = __spreadArrays(callTargetDisplayParts, prefix); - var suffixDisplayParts = __spreadArrays(suffix, returnTypeToDisplayParts(candidateSignature, enclosingDeclaration, checker)); + var prefixDisplayParts = __spreadArray(__spreadArray([], callTargetDisplayParts), prefix); + var suffixDisplayParts = __spreadArray(__spreadArray([], suffix), returnTypeToDisplayParts(candidateSignature, enclosingDeclaration, checker)); var documentation = candidateSignature.getDocumentationComment(checker); var tags = candidateSignature.getJsDocTags(); return { isVariadic: isVariadic, prefixDisplayParts: prefixDisplayParts, suffixDisplayParts: suffixDisplayParts, separatorDisplayParts: separatorDisplayParts, parameters: parameters, documentation: documentation, tags: tags }; @@ -128718,11 +130576,11 @@ var ts; var parameters = (typeParameters || ts.emptyArray).map(function (t) { return createSignatureHelpParameterForTypeParameter(t, checker, enclosingDeclaration, sourceFile, printer); }); var thisParameter = candidateSignature.thisParameter ? [checker.symbolToParameterDeclaration(candidateSignature.thisParameter, enclosingDeclaration, signatureHelpNodeBuilderFlags)] : []; return checker.getExpandedParameters(candidateSignature).map(function (paramList) { - var params = ts.factory.createNodeArray(__spreadArrays(thisParameter, ts.map(paramList, function (param) { return checker.symbolToParameterDeclaration(param, enclosingDeclaration, signatureHelpNodeBuilderFlags); }))); + var params = ts.factory.createNodeArray(__spreadArray(__spreadArray([], thisParameter), ts.map(paramList, function (param) { return checker.symbolToParameterDeclaration(param, enclosingDeclaration, signatureHelpNodeBuilderFlags); }))); var parameterParts = ts.mapToDisplayParts(function (writer) { printer.writeList(2576 /* CallExpressionArguments */, params, sourceFile, writer); }); - return { isVariadic: false, parameters: parameters, prefix: [ts.punctuationPart(29 /* LessThanToken */)], suffix: __spreadArrays([ts.punctuationPart(31 /* GreaterThanToken */)], parameterParts) }; + return { isVariadic: false, parameters: parameters, prefix: [ts.punctuationPart(29 /* LessThanToken */)], suffix: __spreadArray([ts.punctuationPart(31 /* GreaterThanToken */)], parameterParts) }; }); } function itemInfoForParameters(candidateSignature, checker, enclosingDeclaration, sourceFile) { @@ -128739,7 +130597,7 @@ var ts; return { isVariadic: isVariadic && (lists.length === 1 || !!(parameterList[parameterList.length - 1].checkFlags & 32768 /* RestParameter */)), parameters: parameterList.map(function (p) { return createSignatureHelpParameterForParameter(p, checker, enclosingDeclaration, sourceFile, printer); }), - prefix: __spreadArrays(typeParameterParts, [ts.punctuationPart(20 /* OpenParenToken */)]), + prefix: __spreadArray(__spreadArray([], typeParameterParts), [ts.punctuationPart(20 /* OpenParenToken */)]), suffix: [ts.punctuationPart(21 /* CloseParenToken */)] }; }); @@ -128750,14 +130608,15 @@ var ts; printer.writeNode(4 /* Unspecified */, param, sourceFile, writer); }); var isOptional = checker.isOptionalParameter(parameter.valueDeclaration); - return { name: parameter.name, documentation: parameter.getDocumentationComment(checker), displayParts: displayParts, isOptional: isOptional }; + var isRest = !!(parameter.checkFlags & 32768 /* RestParameter */); + return { name: parameter.name, documentation: parameter.getDocumentationComment(checker), displayParts: displayParts, isOptional: isOptional, isRest: isRest }; } function createSignatureHelpParameterForTypeParameter(typeParameter, checker, enclosingDeclaration, sourceFile, printer) { var displayParts = ts.mapToDisplayParts(function (writer) { var param = checker.typeParameterToDeclaration(typeParameter, enclosingDeclaration, signatureHelpNodeBuilderFlags); printer.writeNode(4 /* Unspecified */, param, sourceFile, writer); }); - return { name: typeParameter.symbol.name, documentation: typeParameter.symbol.getDocumentationComment(checker), displayParts: displayParts, isOptional: false }; + return { name: typeParameter.symbol.name, documentation: typeParameter.symbol.getDocumentationComment(checker), displayParts: displayParts, isOptional: false, isRest: false }; } })(SignatureHelp = ts.SignatureHelp || (ts.SignatureHelp = {})); })(ts || (ts = {})); @@ -129020,7 +130879,7 @@ var ts; return !ts.isAsyncFunction(node) && node.body && ts.isBlock(node.body) && - hasReturnStatementWithPromiseHandler(node.body) && + hasReturnStatementWithPromiseHandler(node.body, checker) && returnsPromise(node, checker); } function returnsPromise(node, checker) { @@ -129032,23 +130891,23 @@ var ts; function getErrorNodeFromCommonJsIndicator(commonJsModuleIndicator) { return ts.isBinaryExpression(commonJsModuleIndicator) ? commonJsModuleIndicator.left : commonJsModuleIndicator; } - function hasReturnStatementWithPromiseHandler(body) { - return !!ts.forEachReturnStatement(body, isReturnStatementWithFixablePromiseHandler); + function hasReturnStatementWithPromiseHandler(body, checker) { + return !!ts.forEachReturnStatement(body, function (statement) { return isReturnStatementWithFixablePromiseHandler(statement, checker); }); } - function isReturnStatementWithFixablePromiseHandler(node) { - return ts.isReturnStatement(node) && !!node.expression && isFixablePromiseHandler(node.expression); + function isReturnStatementWithFixablePromiseHandler(node, checker) { + return ts.isReturnStatement(node) && !!node.expression && isFixablePromiseHandler(node.expression, checker); } ts.isReturnStatementWithFixablePromiseHandler = isReturnStatementWithFixablePromiseHandler; // Should be kept up to date with transformExpression in convertToAsyncFunction.ts - function isFixablePromiseHandler(node) { + function isFixablePromiseHandler(node, checker) { // ensure outermost call exists and is a promise handler - if (!isPromiseHandler(node) || !node.arguments.every(isFixablePromiseArgument)) { + if (!isPromiseHandler(node) || !node.arguments.every(function (arg) { return isFixablePromiseArgument(arg, checker); })) { return false; } // ensure all chained calls are valid var currentNode = node.expression; while (isPromiseHandler(currentNode) || ts.isPropertyAccessExpression(currentNode)) { - if (ts.isCallExpression(currentNode) && !currentNode.arguments.every(isFixablePromiseArgument)) { + if (ts.isCallExpression(currentNode) && !currentNode.arguments.every(function (arg) { return isFixablePromiseArgument(arg, checker); })) { return false; } currentNode = currentNode.expression; @@ -129071,7 +130930,7 @@ var ts; }); } // should be kept up to date with getTransformationBody in convertToAsyncFunction.ts - function isFixablePromiseArgument(arg) { + function isFixablePromiseArgument(arg, checker) { switch (arg.kind) { case 251 /* FunctionDeclaration */: case 208 /* FunctionExpression */: @@ -129079,8 +130938,16 @@ var ts; visitedNestedConvertibleFunctions.set(getKeyFromNode(arg), true); // falls through case 103 /* NullKeyword */: - case 78 /* Identifier */: // identifier includes undefined return true; + case 78 /* Identifier */: + case 201 /* PropertyAccessExpression */: { + var symbol = checker.getSymbolAtLocation(arg); + if (!symbol) { + return false; + } + return checker.isUndefinedSymbol(symbol) || + ts.some(ts.skipAlias(symbol, checker).declarations, function (d) { return ts.isFunctionLike(d) || ts.hasInitializer(d) && !!d.initializer && ts.isFunctionLike(d.initializer); }); + } default: return false; } @@ -129186,8 +131053,6 @@ var ts; if (rootSymbolFlags & (98308 /* PropertyOrAccessor */ | 3 /* Variable */)) { return "property" /* memberVariableElement */; } - // May be a Function if this was from `typeof N` with `namespace N { function f();. }`. - ts.Debug.assert(!!(rootSymbolFlags & (8192 /* Method */ | 16 /* Function */))); }); if (!unionPropertyKind) { // If this was union of all methods, @@ -129215,14 +131080,40 @@ var ts; } return "" /* unknown */; } - function getSymbolModifiers(symbol) { - var nodeModifiers = symbol && symbol.declarations && symbol.declarations.length > 0 - ? ts.getNodeModifiers(symbol.declarations[0]) - : "" /* none */; - var symbolModifiers = symbol && symbol.flags & 16777216 /* Optional */ ? - "optional" /* optionalModifier */ - : "" /* none */; - return nodeModifiers && symbolModifiers ? nodeModifiers + "," + symbolModifiers : nodeModifiers || symbolModifiers; + function isDeprecatedDeclaration(decl) { + return !!(ts.getCombinedNodeFlagsAlwaysIncludeJSDoc(decl) & 8192 /* Deprecated */); + } + function getNormalizedSymbolModifiers(symbol) { + if (symbol.declarations && symbol.declarations.length) { + var _a = symbol.declarations, declaration = _a[0], declarations = _a.slice(1); + // omit deprecated flag if some declarations are not deprecated + var excludeFlags = ts.length(declarations) && isDeprecatedDeclaration(declaration) && ts.some(declarations, function (d) { return !isDeprecatedDeclaration(d); }) + ? 8192 /* Deprecated */ + : 0 /* None */; + var modifiers = ts.getNodeModifiers(declaration, excludeFlags); + if (modifiers) { + return modifiers.split(","); + } + } + return []; + } + function getSymbolModifiers(typeChecker, symbol) { + if (!symbol) { + return "" /* none */; + } + var modifiers = new ts.Set(getNormalizedSymbolModifiers(symbol)); + if (symbol.flags & 2097152 /* Alias */) { + var resolvedSymbol = typeChecker.getAliasedSymbol(symbol); + if (resolvedSymbol !== symbol) { + ts.forEach(getNormalizedSymbolModifiers(resolvedSymbol), function (modifier) { + modifiers.add(modifier); + }); + } + } + if (symbol.flags & 16777216 /* Optional */) { + modifiers.add("optional" /* optionalModifier */); + } + return modifiers.size > 0 ? ts.arrayFrom(modifiers.values()).join(",") : "" /* none */; } SymbolDisplay.getSymbolModifiers = getSymbolModifiers; // TODO(drosen): Currently completion entry details passes the SemanticMeaning.All instead of using semanticMeaning of location @@ -129289,6 +131180,10 @@ var ts; pushSymbolKind(symbolKind); displayParts.push(ts.spacePart()); if (useConstructSignatures) { + if (signature.flags & 4 /* Abstract */) { + displayParts.push(ts.keywordPart(125 /* AbstractKeyword */)); + displayParts.push(ts.spacePart()); + } displayParts.push(ts.keywordPart(102 /* NewKeyword */)); displayParts.push(ts.spacePart()); } @@ -129313,6 +131208,10 @@ var ts; displayParts.push(ts.lineBreakPart()); } if (useConstructSignatures) { + if (signature.flags & 4 /* Abstract */) { + displayParts.push(ts.keywordPart(125 /* AbstractKeyword */)); + displayParts.push(ts.spacePart()); + } displayParts.push(ts.keywordPart(102 /* NewKeyword */)); displayParts.push(ts.spacePart()); } @@ -129487,6 +131386,10 @@ var ts; documentationFromAlias = resolvedInfo.documentation; tagsFromAlias = resolvedInfo.tags; } + else { + documentationFromAlias = resolvedSymbol.getContextualDocumentationComment(resolvedNode, typeChecker); + tagsFromAlias = resolvedSymbol.getJsDocTags(); + } } } switch (symbol.declarations[0].kind) { @@ -130244,8 +132147,8 @@ var ts; return { tokens: allTokens.filter(function (t) { return !tokens.some(function (t2) { return t2 === t; }); }), isSpecific: false }; } var anyToken = { tokens: allTokens, isSpecific: false }; - var anyTokenIncludingMultilineComments = tokenRangeFrom(__spreadArrays(allTokens, [3 /* MultiLineCommentTrivia */])); - var anyTokenIncludingEOF = tokenRangeFrom(__spreadArrays(allTokens, [1 /* EndOfFileToken */])); + var anyTokenIncludingMultilineComments = tokenRangeFrom(__spreadArray(__spreadArray([], allTokens), [3 /* MultiLineCommentTrivia */])); + var anyTokenIncludingEOF = tokenRangeFrom(__spreadArray(__spreadArray([], allTokens), [1 /* EndOfFileToken */])); var keywords = tokenRangeFromRange(80 /* FirstKeyword */, 156 /* LastKeyword */); var binaryOperators = tokenRangeFromRange(29 /* FirstBinaryOperator */, 77 /* LastBinaryOperator */); var binaryKeywordOperators = [100 /* InKeyword */, 101 /* InstanceOfKeyword */, 156 /* OfKeyword */, 126 /* AsKeyword */, 137 /* IsKeyword */]; @@ -130259,7 +132162,7 @@ var ts; var unaryPredecrementExpressions = [78 /* Identifier */, 20 /* OpenParenToken */, 107 /* ThisKeyword */, 102 /* NewKeyword */]; var unaryPostdecrementExpressions = [78 /* Identifier */, 21 /* CloseParenToken */, 23 /* CloseBracketToken */, 102 /* NewKeyword */]; var comments = [2 /* SingleLineCommentTrivia */, 3 /* MultiLineCommentTrivia */]; - var typeNames = __spreadArrays([78 /* Identifier */], ts.typeKeywords); + var typeNames = __spreadArray([78 /* Identifier */], ts.typeKeywords); // Place a space before open brace in a function declaration // TypeScript: Function can have return types, which can be made of tons of different token kinds var functionOpenBraceLeftTokenRange = anyTokenIncludingMultilineComments; @@ -130502,7 +132405,7 @@ var ts; // This low-pri rule takes care of "try {", "catch {" and "finally {" in case the rule SpaceBeforeOpenBraceInControl didn't execute on FormatOnEnter. rule("SpaceAfterTryCatchFinally", [110 /* TryKeyword */, 82 /* CatchKeyword */, 95 /* FinallyKeyword */], 18 /* OpenBraceToken */, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */), ]; - return __spreadArrays(highPriorityCommonRules, userConfigurableRules, lowPriorityCommonRules); + return __spreadArray(__spreadArray(__spreadArray([], highPriorityCommonRules), userConfigurableRules), lowPriorityCommonRules); } formatting.getAllRules = getAllRules; /** @@ -131385,14 +133288,17 @@ var ts; processNode(enclosingNode, enclosingNode, startLine, undecoratedStartLine, initialIndentation, delta); } if (!formattingScanner.isOnToken()) { + var indentation = formatting.SmartIndenter.nodeWillIndentChild(options, enclosingNode, /*child*/ undefined, sourceFile, /*indentByDefault*/ false) + ? initialIndentation + options.indentSize + : initialIndentation; var leadingTrivia = formattingScanner.getCurrentLeadingTrivia(); if (leadingTrivia) { - indentTriviaItems(leadingTrivia, initialIndentation, /*indentNextTokenOrTrivia*/ false, function (item) { return processRange(item, sourceFile.getLineAndCharacterOfPosition(item.pos), enclosingNode, enclosingNode, /*dynamicIndentation*/ undefined); }); - if (options.trimTrailingWhitespace !== false) { - trimTrailingWhitespacesForRemainingRange(); - } + indentTriviaItems(leadingTrivia, indentation, /*indentNextTokenOrTrivia*/ false, function (item) { return processRange(item, sourceFile.getLineAndCharacterOfPosition(item.pos), enclosingNode, enclosingNode, /*dynamicIndentation*/ undefined); }); } } + if (options.trimTrailingWhitespace !== false) { + trimTrailingWhitespacesForRemainingRange(); + } return edits; // local functions /** Tries to compute the indentation for a list element. @@ -131439,10 +133345,9 @@ var ts; // - we need to get the indentation on last line and the delta of parent return { indentation: indentationOnLastIndentedLine, delta: parentDynamicIndentation.getDelta(node) }; } - else if (formatting.SmartIndenter.childStartsOnTheSameLineWithElseInIfStatement(parent, node, startLine, sourceFile)) { - return { indentation: parentDynamicIndentation.getIndentation(), delta: delta }; - } - else if (formatting.SmartIndenter.argumentStartsOnSameLineAsPreviousArgument(parent, node, startLine, sourceFile)) { + else if (formatting.SmartIndenter.childStartsOnTheSameLineWithElseInIfStatement(parent, node, startLine, sourceFile) || + formatting.SmartIndenter.childIsUnindentedBranchOfConditionalExpression(parent, node, startLine, sourceFile) || + formatting.SmartIndenter.argumentStartsOnSameLineAsPreviousArgument(parent, node, startLine, sourceFile)) { return { indentation: parentDynamicIndentation.getIndentation(), delta: delta }; } else { @@ -131530,6 +133435,7 @@ var ts; case 275 /* JsxOpeningElement */: case 276 /* JsxClosingElement */: case 274 /* JsxSelfClosingElement */: + case 223 /* ExpressionWithTypeArguments */: return false; } break; @@ -132331,6 +134237,7 @@ var ts; } SmartIndenter.getBaseIndentation = getBaseIndentation; function getIndentationForNodeWorker(current, currentStart, ignoreActualIndentationRange, indentationDelta, sourceFile, isNextChild, options) { + var _a; var parent = current.parent; // Walk up the tree and collect indentation for parent-child node pairs. Indentation is not added if // * parent and child nodes start on the same line, or @@ -132346,7 +134253,25 @@ var ts; childStartsOnTheSameLineWithElseInIfStatement(parent, current, currentStart.line, sourceFile); if (useActualIndentation) { // check if current node is a list item - if yes, take indentation from it - var actualIndentation = getActualIndentationForListItem(current, sourceFile, options, !parentAndChildShareLine); + var firstListChild = (_a = getContainingList(current, sourceFile)) === null || _a === void 0 ? void 0 : _a[0]; + // A list indents its children if the children begin on a later line than the list itself: + // + // f1( L0 - List start + // { L1 - First child start: indented, along with all other children + // prop: 0 + // }, + // { + // prop: 1 + // } + // ) + // + // f2({ L0 - List start and first child start: children are not indented. + // prop: 0 Object properties are indented only one level, because the list + // }, { itself contributes nothing. + // prop: 1 L3 - The indentation of the second object literal is best understood by + // }) looking at the relationship between the list and *first* list item. + var listIndentsChild = !!firstListChild && getStartLineAndCharacterForNode(firstListChild, sourceFile).line > containingListOrParentStart.line; + var actualIndentation = getActualIndentationForListItem(current, sourceFile, options, listIndentsChild); if (actualIndentation !== -1 /* Unknown */) { return actualIndentation + indentationDelta; } @@ -132459,6 +134384,49 @@ var ts; return false; } SmartIndenter.childStartsOnTheSameLineWithElseInIfStatement = childStartsOnTheSameLineWithElseInIfStatement; + // A multiline conditional typically increases the indentation of its whenTrue and whenFalse children: + // + // condition + // ? whenTrue + // : whenFalse; + // + // However, that indentation does not apply if the subexpressions themselves span multiple lines, + // applying their own indentation: + // + // (() => { + // return complexCalculationForCondition(); + // })() ? { + // whenTrue: 'multiline object literal' + // } : ( + // whenFalse('multiline parenthesized expression') + // ); + // + // In these cases, we must discard the indentation increase that would otherwise be applied to the + // whenTrue and whenFalse children to avoid double-indenting their contents. To identify this scenario, + // we check for the whenTrue branch beginning on the line that the condition ends, and the whenFalse + // branch beginning on the line that the whenTrue branch ends. + function childIsUnindentedBranchOfConditionalExpression(parent, child, childStartLine, sourceFile) { + if (ts.isConditionalExpression(parent) && (child === parent.whenTrue || child === parent.whenFalse)) { + var conditionEndLine = ts.getLineAndCharacterOfPosition(sourceFile, parent.condition.end).line; + if (child === parent.whenTrue) { + return childStartLine === conditionEndLine; + } + else { + // On the whenFalse side, we have to look at the whenTrue side, because if that one was + // indented, whenFalse must also be indented: + // + // const y = true + // ? 1 : ( L1: whenTrue indented because it's on a new line + // 0 L2: indented two stops, one because whenTrue was indented + // ); and one because of the parentheses spanning multiple lines + var trueStartLine = getStartLineAndCharacterForNode(parent.whenTrue, sourceFile).line; + var trueEndLine = ts.getLineAndCharacterOfPosition(sourceFile, parent.whenTrue.end).line; + return conditionEndLine === trueStartLine && trueEndLine === childStartLine; + } + } + return false; + } + SmartIndenter.childIsUnindentedBranchOfConditionalExpression = childIsUnindentedBranchOfConditionalExpression; function argumentStartsOnSameLineAsPreviousArgument(parent, child, childStartLine, sourceFile) { if (ts.isCallOrNewExpression(parent)) { if (!parent.arguments) @@ -132704,7 +134672,7 @@ var ts; if (childKind === 177 /* TypeLiteral */ || childKind === 179 /* TupleType */) { return false; } - // falls through + break; } // No explicit rule for given nodes so the result will follow the default value argument return indentByDefault; @@ -133031,17 +134999,12 @@ var ts; if (options === void 0) { options = {}; } this.insertNodeAt(sourceFile, getAdjustedStartPosition(sourceFile, before, options), newNode, this.getOptionsForInsertNodeBefore(before, newNode, blankLineBetween)); }; - ChangeTracker.prototype.insertModifierBefore = function (sourceFile, modifier, before) { - var pos = before.getStart(sourceFile); - this.insertNodeAt(sourceFile, pos, ts.factory.createToken(modifier), { suffix: " " }); + ChangeTracker.prototype.insertModifierAt = function (sourceFile, pos, modifier, options) { + if (options === void 0) { options = {}; } + this.insertNodeAt(sourceFile, pos, ts.factory.createToken(modifier), options); }; - ChangeTracker.prototype.insertLastModifierBefore = function (sourceFile, modifier, before) { - if (!before.modifiers) { - this.insertModifierBefore(sourceFile, modifier, before); - return; - } - var pos = before.modifiers.end; - this.insertNodeAt(sourceFile, pos, ts.factory.createToken(modifier), { prefix: " " }); + ChangeTracker.prototype.insertModifierBefore = function (sourceFile, modifier, before) { + return this.insertModifierAt(sourceFile, before.getStart(sourceFile), modifier, { suffix: " " }); }; ChangeTracker.prototype.insertCommentBeforeLine = function (sourceFile, lineNumber, position, commentText) { var lineStartPosition = ts.getStartPositionOfLine(lineNumber, sourceFile); @@ -133127,7 +135090,7 @@ var ts; ChangeTracker.prototype.insertNodeAtConstructorStart = function (sourceFile, ctr, newStatement) { var firstStatement = ts.firstOrUndefined(ctr.body.statements); if (!firstStatement || !ctr.body.multiLine) { - this.replaceConstructorBody(sourceFile, ctr, __spreadArrays([newStatement], ctr.body.statements)); + this.replaceConstructorBody(sourceFile, ctr, __spreadArray([newStatement], ctr.body.statements)); } else { this.insertNodeBefore(sourceFile, firstStatement, newStatement); @@ -133136,7 +135099,7 @@ var ts; ChangeTracker.prototype.insertNodeAtConstructorEnd = function (sourceFile, ctr, newStatement) { var lastStatement = ts.lastOrUndefined(ctr.body.statements); if (!lastStatement || !ctr.body.multiLine) { - this.replaceConstructorBody(sourceFile, ctr, __spreadArrays(ctr.body.statements, [newStatement])); + this.replaceConstructorBody(sourceFile, ctr, __spreadArray(__spreadArray([], ctr.body.statements), [newStatement])); } else { this.insertNodeAfter(sourceFile, lastStatement, newStatement); @@ -133436,7 +135399,7 @@ var ts; var _loop_9 = function (sourceFile, node) { if (!this_1.deletedNodes.some(function (d) { return d.sourceFile === sourceFile && ts.rangeContainsRangeExclusive(d.node, node); })) { if (ts.isArray(node)) { - this_1.deleteRange(sourceFile, ts.rangeOfTypeParameters(node)); + this_1.deleteRange(sourceFile, ts.rangeOfTypeParameters(sourceFile, node)); } else { deleteDeclaration.deleteDeclaration(this_1, deletedNodesInLists, sourceFile, node); @@ -134127,7 +136090,7 @@ var ts; codefix.eachDiagnostic = eachDiagnostic; function getDiagnostics(_a) { var program = _a.program, sourceFile = _a.sourceFile, cancellationToken = _a.cancellationToken; - return __spreadArrays(program.getSemanticDiagnostics(sourceFile, cancellationToken), program.getSyntacticDiagnostics(sourceFile, cancellationToken), ts.computeSuggestionDiagnostics(sourceFile, program, cancellationToken)); + return __spreadArray(__spreadArray(__spreadArray([], program.getSemanticDiagnostics(sourceFile, cancellationToken)), program.getSyntacticDiagnostics(sourceFile, cancellationToken)), ts.computeSuggestionDiagnostics(sourceFile, program, cancellationToken)); } })(codefix = ts.codefix || (ts.codefix = {})); })(ts || (ts = {})); @@ -134146,7 +136109,10 @@ var ts; refactor_1.registerRefactor = registerRefactor; function getApplicableRefactors(context) { return ts.arrayFrom(ts.flatMapIterator(refactors.values(), function (refactor) { - return context.cancellationToken && context.cancellationToken.isCancellationRequested() ? undefined : refactor.getAvailableActions(context); + var _a; + return context.cancellationToken && context.cancellationToken.isCancellationRequested() || + !((_a = refactor.kinds) === null || _a === void 0 ? void 0 : _a.some(function (kind) { return refactor_1.refactorKindBeginsWith(kind, context.kind); })) ? undefined : + refactor.getAvailableActions(context); })); } refactor_1.getApplicableRefactors = getApplicableRefactors; @@ -134189,7 +136155,10 @@ var ts; var codefix; (function (codefix) { codefix.registerCodeFix({ - errorCodes: [ts.Diagnostics.await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module.code], + errorCodes: [ + ts.Diagnostics.await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module.code, + ts.Diagnostics.for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module.code, + ], getCodeActions: function (context) { var sourceFile = context.sourceFile; var changes = ts.textChanges.ChangeTracker.with(context, function (changes) { @@ -134295,7 +136264,7 @@ var ts; ts.Diagnostics.This_expression_is_not_callable.code, ts.Diagnostics.This_expression_is_not_constructable.code, ]; - var errorCodes = __spreadArrays([ + var errorCodes = __spreadArray([ ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type.code, ts.Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type.code, ts.Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type.code, @@ -134914,13 +136883,17 @@ var ts; codefix.registerCodeFix({ errorCodes: errorCodes, getCodeActions: function (context) { - var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, context.sourceFile, context.span.start, context.program.getTypeChecker()); }); + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { + return doChange(t, context.sourceFile, context.span.start, context.program.getTypeChecker(), context.preferences, context.program.getCompilerOptions()); + }); return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Convert_function_to_an_ES2015_class, fixId, ts.Diagnostics.Convert_all_constructor_functions_to_classes)]; }, fixIds: [fixId], - getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, err) { return doChange(changes, err.file, err.start, context.program.getTypeChecker()); }); }, + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, err) { + return doChange(changes, err.file, err.start, context.program.getTypeChecker(), context.preferences, context.program.getCompilerOptions()); + }); }, }); - function doChange(changes, sourceFile, position, checker) { + function doChange(changes, sourceFile, position, checker, preferences, compilerOptions) { var ctorSymbol = checker.getSymbolAtLocation(ts.getTokenAtPosition(sourceFile, position)); if (!ctorSymbol || !(ctorSymbol.flags & (16 /* Function */ | 3 /* Variable */))) { // Bad input @@ -134991,8 +136964,8 @@ var ts; // Right now the only thing we can convert are function expressions, get/set accessors and methods // other values like normal value fields ({a: 1}) shouldn't get transformed. // We can update this once ES public class properties are available. - if (ts.isPropertyAccessExpression(_target)) { - if (isConstructorAssignment(_target)) + if (ts.isAccessExpression(_target)) { + if (ts.isPropertyAccessExpression(_target) && isConstructorAssignment(_target)) return true; return ts.isFunctionLike(source); } @@ -135034,8 +137007,13 @@ var ts; return members; } // f.x = expr - if (ts.isPropertyAccessExpression(memberDeclaration) && (ts.isFunctionExpression(assignmentExpr) || ts.isArrowFunction(assignmentExpr))) { - return createFunctionLikeExpressionMember(members, assignmentExpr, memberDeclaration.name); + if (ts.isAccessExpression(memberDeclaration) && (ts.isFunctionExpression(assignmentExpr) || ts.isArrowFunction(assignmentExpr))) { + var quotePreference = ts.getQuotePreference(sourceFile, preferences); + var name = tryGetPropertyName(memberDeclaration, compilerOptions, quotePreference); + if (name) { + return createFunctionLikeExpressionMember(members, assignmentExpr, name); + } + return members; } // f.prototype = { ... } else if (ts.isObjectLiteralExpression(assignmentExpr)) { @@ -135133,6 +137111,21 @@ var ts; return true; return false; } + function tryGetPropertyName(node, compilerOptions, quotePreference) { + if (ts.isPropertyAccessExpression(node)) { + return node.name; + } + var propName = node.argumentExpression; + if (ts.isNumericLiteral(propName)) { + return propName; + } + if (ts.isStringLiteralLike(propName)) { + return ts.isIdentifierText(propName.text, compilerOptions.target) ? ts.factory.createIdentifier(propName.text) + : ts.isNoSubstitutionTemplateLiteral(propName) ? ts.factory.createStringLiteral(propName.text, quotePreference === 0 /* Single */) + : propName; + } + return undefined; + } })(codefix = ts.codefix || (ts.codefix = {})); })(ts || (ts = {})); /* @internal */ @@ -135147,18 +137140,18 @@ var ts; errorCodes: errorCodes, getCodeActions: function (context) { codeActionSucceeded = true; - var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return convertToAsyncFunction(t, context.sourceFile, context.span.start, context.program.getTypeChecker(), context); }); + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return convertToAsyncFunction(t, context.sourceFile, context.span.start, context.program.getTypeChecker()); }); return codeActionSucceeded ? [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Convert_to_async_function, fixId, ts.Diagnostics.Convert_all_to_async_functions)] : []; }, fixIds: [fixId], - getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, err) { return convertToAsyncFunction(changes, err.file, err.start, context.program.getTypeChecker(), context); }); }, + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, err) { return convertToAsyncFunction(changes, err.file, err.start, context.program.getTypeChecker()); }); }, }); var SynthBindingNameKind; (function (SynthBindingNameKind) { SynthBindingNameKind[SynthBindingNameKind["Identifier"] = 0] = "Identifier"; SynthBindingNameKind[SynthBindingNameKind["BindingPattern"] = 1] = "BindingPattern"; })(SynthBindingNameKind || (SynthBindingNameKind = {})); - function convertToAsyncFunction(changes, sourceFile, position, checker, context) { + function convertToAsyncFunction(changes, sourceFile, position, checker) { // get the function declaration - returns a promise var tokenAtPosition = ts.getTokenAtPosition(sourceFile, position); var functionToConvert; @@ -135176,14 +137169,17 @@ var ts; var synthNamesMap = new ts.Map(); var isInJavascript = ts.isInJSFile(functionToConvert); var setOfExpressionsToReturn = getAllPromiseExpressionsToReturn(functionToConvert, checker); - var functionToConvertRenamed = renameCollidingVarNames(functionToConvert, checker, synthNamesMap, context.sourceFile); - var returnStatements = functionToConvertRenamed.body && ts.isBlock(functionToConvertRenamed.body) ? getReturnStatementsWithPromiseHandlers(functionToConvertRenamed.body) : ts.emptyArray; + var functionToConvertRenamed = renameCollidingVarNames(functionToConvert, checker, synthNamesMap); + var returnStatements = functionToConvertRenamed.body && ts.isBlock(functionToConvertRenamed.body) ? getReturnStatementsWithPromiseHandlers(functionToConvertRenamed.body, checker) : ts.emptyArray; var transformer = { checker: checker, synthNamesMap: synthNamesMap, setOfExpressionsToReturn: setOfExpressionsToReturn, isInJSFile: isInJavascript }; if (!returnStatements.length) { return; } - // add the async keyword - changes.insertLastModifierBefore(sourceFile, 129 /* AsyncKeyword */, functionToConvert); + var pos = functionToConvert.modifiers ? functionToConvert.modifiers.end : + functionToConvert.decorators ? ts.skipTrivia(sourceFile.text, functionToConvert.decorators.end) : + functionToConvert.getStart(sourceFile); + var options = functionToConvert.modifiers ? { prefix: " " } : { suffix: " " }; + changes.insertModifierAt(sourceFile, pos, 129 /* AsyncKeyword */, options); var _loop_12 = function (returnStatement) { ts.forEachChild(returnStatement, function visit(node) { if (ts.isCallExpression(node)) { @@ -135200,10 +137196,10 @@ var ts; _loop_12(returnStatement); } } - function getReturnStatementsWithPromiseHandlers(body) { + function getReturnStatementsWithPromiseHandlers(body, checker) { var res = []; ts.forEachReturnStatement(body, function (ret) { - if (ts.isReturnStatementWithFixablePromiseHandler(ret)) + if (ts.isReturnStatementWithFixablePromiseHandler(ret, checker)) res.push(ret); }); return res; @@ -135248,15 +137244,12 @@ var ts; return false; return !!checker.getPromisedTypeOfPromise(checker.getTypeAtLocation(node)); } - function declaredInFile(symbol, sourceFile) { - return symbol.valueDeclaration && symbol.valueDeclaration.getSourceFile() === sourceFile; - } /* - Renaming of identifiers may be neccesary as the refactor changes scopes - + Renaming of identifiers may be necessary as the refactor changes scopes - This function collects all existing identifier names and names of identifiers that will be created in the refactor. It then checks for any collisions and renames them through getSynthesizedDeepClone */ - function renameCollidingVarNames(nodeToRename, checker, synthNamesMap, sourceFile) { + function renameCollidingVarNames(nodeToRename, checker, synthNamesMap) { var identsToRenameMap = new ts.Map(); // key is the symbol id var collidingSymbolMap = ts.createMultiMap(); ts.forEachChild(nodeToRename, function visit(node) { @@ -135265,8 +137258,7 @@ var ts; return; } var symbol = checker.getSymbolAtLocation(node); - var isDefinedInFile = symbol && declaredInFile(symbol, sourceFile); - if (symbol && isDefinedInFile) { + if (symbol) { var type = checker.getTypeAtLocation(node); // Note - the choice of the last call signature is arbitrary var lastCallSignature = getLastCallSignature(type, checker); @@ -135337,8 +137329,6 @@ var ts; return transformThen(node, transformer, prevArgName); } if (isPromiseReturningCallExpression(node, transformer.checker, "catch")) { - if (node.arguments.length === 0) - return silentFail(); return transformCatch(node, transformer, prevArgName); } if (ts.isPropertyAccessExpression(node)) { @@ -135352,14 +137342,12 @@ var ts; return silentFail(); } function transformCatch(node, transformer, prevArgName) { - var func = node.arguments[0]; - var argName = getArgBindingName(func, transformer); + var func = ts.singleOrUndefined(node.arguments); + var argName = func ? getArgBindingName(func, transformer) : undefined; var possibleNameForVarDecl; - /* - If there is another call in the chain after the .catch() we are transforming, we will need to save the result of both paths (try block and catch block) - To do this, we will need to synthesize a variable that we were not aware of while we were adding identifiers to the synthNamesMap - We will use the prevArgName and then update the synthNamesMap with a new variable name for the next transformation step - */ + // If there is another call in the chain after the .catch() we are transforming, we will need to save the result of both paths (try block and catch block) + // To do this, we will need to synthesize a variable that we were not aware of while we were adding identifiers to the synthNamesMap + // We will use the prevArgName and then update the synthNamesMap with a new variable name for the next transformation step if (prevArgName && !shouldReturn(node, transformer)) { if (isSynthIdentifier(prevArgName)) { possibleNameForVarDecl = prevArgName; @@ -135379,13 +137367,11 @@ var ts; possibleNameForVarDecl.hasBeenDeclared = true; } var tryBlock = ts.factory.createBlock(transformExpression(node.expression, transformer, possibleNameForVarDecl)); - var transformationBody = getTransformationBody(func, possibleNameForVarDecl, argName, node, transformer); + var transformationBody = func ? getTransformationBody(func, possibleNameForVarDecl, argName, node, transformer) : ts.emptyArray; var catchArg = argName ? isSynthIdentifier(argName) ? argName.identifier.text : argName.bindingPattern : "e"; var catchVariableDeclaration = ts.factory.createVariableDeclaration(catchArg); var catchClause = ts.factory.createCatchClause(catchVariableDeclaration, ts.factory.createBlock(transformationBody)); - /* - In order to avoid an implicit any, we will synthesize a type for the declaration using the unions of the types of both paths (try block and catch block) - */ + // In order to avoid an implicit any, we will synthesize a type for the declaration using the unions of the types of both paths (try block and catch block) var varDeclList; var varDeclIdentifier; if (possibleNameForVarDecl && !shouldReturn(node, transformer)) { @@ -135449,7 +137435,7 @@ var ts; function maybeAnnotateAndReturn(expressionToReturn, typeAnnotation) { if (typeAnnotation && expressionToReturn) { var name = ts.factory.createUniqueName("result", 16 /* Optimistic */); - return __spreadArrays(createVariableOrAssignmentOrExpressionStatement(createSynthIdentifier(name), expressionToReturn, typeAnnotation), [ + return __spreadArray(__spreadArray([], createVariableOrAssignmentOrExpressionStatement(createSynthIdentifier(name), expressionToReturn, typeAnnotation)), [ ts.factory.createReturnStatement(name) ]); } @@ -135462,6 +137448,7 @@ var ts; case 103 /* NullKeyword */: // do not produce a transformed statement for a null argument break; + case 201 /* PropertyAccessExpression */: case 78 /* Identifier */: // identifier includes undefined if (!argName) { // undefined was argument passed to promise handler @@ -135495,7 +137482,7 @@ var ts; var statement = _f[_i]; if (ts.isReturnStatement(statement)) { seenReturnStatement = true; - if (ts.isReturnStatementWithFixablePromiseHandler(statement)) { + if (ts.isReturnStatementWithFixablePromiseHandler(statement, transformer.checker)) { refactoredStmts = refactoredStmts.concat(getInnerTransformationBody(transformer, [statement], prevArgName)); } else { @@ -135512,7 +137499,7 @@ var ts; : removeReturns(refactoredStmts, prevArgName, transformer, seenReturnStatement); } else { - var innerRetStmts = ts.isFixablePromiseHandler(funcBody) ? [ts.factory.createReturnStatement(funcBody)] : ts.emptyArray; + var innerRetStmts = ts.isFixablePromiseHandler(funcBody, transformer.checker) ? [ts.factory.createReturnStatement(funcBody)] : ts.emptyArray; var innerCbBody = getInnerTransformationBody(transformer, innerRetStmts, prevArgName); if (innerCbBody.length > 0) { return innerCbBody; @@ -135605,6 +137592,9 @@ var ts; else if (ts.isIdentifier(funcNode)) { name = getMapEntryOrDefault(funcNode); } + else if (ts.isPropertyAccessExpression(funcNode) && ts.isIdentifier(funcNode.name)) { + name = getMapEntryOrDefault(funcNode.name); + } // return undefined argName when arg is null or undefined // eslint-disable-next-line no-in-operator if (!name || "identifier" in name && name.identifier.text === "undefined") { @@ -136252,7 +138242,7 @@ var ts; (function (ts) { var codefix; (function (codefix) { - var errorCodes = [ts.Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is_set_to_error.code]; + var errorCodes = [ts.Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error.code]; var fixId = "convertToTypeOnlyImport"; codefix.registerCodeFix({ errorCodes: errorCodes, @@ -136590,10 +138580,12 @@ var ts; })(ImportKind || (ImportKind = {})); function getImportCompletionAction(exportedSymbol, moduleSymbol, sourceFile, symbolName, host, program, formatContext, position, preferences) { var compilerOptions = program.getCompilerOptions(); - var exportInfos = getAllReExportingModules(sourceFile, exportedSymbol, moduleSymbol, symbolName, host, program, /*useAutoImportProvider*/ true); + var exportInfos = ts.pathIsBareSpecifier(ts.stripQuotes(moduleSymbol.name)) + ? [getSymbolExportInfoForSymbol(exportedSymbol, moduleSymbol, sourceFile, program, host)] + : getAllReExportingModules(sourceFile, exportedSymbol, moduleSymbol, symbolName, host, program, /*useAutoImportProvider*/ true); var useRequire = shouldUseRequire(sourceFile, program); var preferTypeOnlyImport = compilerOptions.importsNotUsedAsValues === 2 /* Error */ && !ts.isSourceFileJS(sourceFile) && ts.isValidTypeOnlyAliasUseSite(ts.getTokenAtPosition(sourceFile, position)); - var moduleSpecifier = ts.first(getNewImportInfos(program, sourceFile, position, preferTypeOnlyImport, useRequire, exportInfos, host, preferences)).moduleSpecifier; + var moduleSpecifier = getBestFix(getNewImportInfos(program, sourceFile, position, preferTypeOnlyImport, useRequire, exportInfos, host, preferences), sourceFile, program, host).moduleSpecifier; var fix = getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, preferTypeOnlyImport, useRequire, host, preferences); return { moduleSpecifier: moduleSpecifier, codeAction: codeFixActionToCodeAction(codeActionForFix({ host: host, formatContext: formatContext, preferences: preferences }, sourceFile, symbolName, fix, ts.getQuotePreference(sourceFile, preferences))) }; } @@ -136601,12 +138593,32 @@ var ts; function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, preferTypeOnlyImport, useRequire, host, preferences) { ts.Debug.assert(exportInfos.some(function (info) { return info.moduleSymbol === moduleSymbol; }), "Some exportInfo should match the specified moduleSymbol"); // We sort the best codefixes first, so taking `first` is best. - return ts.first(getFixForImport(exportInfos, symbolName, position, preferTypeOnlyImport, useRequire, program, sourceFile, host, preferences)); + return getBestFix(getFixForImport(exportInfos, symbolName, position, preferTypeOnlyImport, useRequire, program, sourceFile, host, preferences), sourceFile, program, host); } function codeFixActionToCodeAction(_a) { var description = _a.description, changes = _a.changes, commands = _a.commands; return { description: description, changes: changes, commands: commands }; } + function getSymbolExportInfoForSymbol(symbol, moduleSymbol, importingFile, program, host) { + var _a, _b; + var compilerOptions = program.getCompilerOptions(); + var mainProgramInfo = getInfoWithChecker(program.getTypeChecker()); + if (mainProgramInfo) { + return mainProgramInfo; + } + var autoImportProvider = (_b = (_a = host.getPackageJsonAutoImportProvider) === null || _a === void 0 ? void 0 : _a.call(host)) === null || _b === void 0 ? void 0 : _b.getTypeChecker(); + return ts.Debug.checkDefined(autoImportProvider && getInfoWithChecker(autoImportProvider), "Could not find symbol in specified module for code actions"); + function getInfoWithChecker(checker) { + var defaultInfo = getDefaultLikeExportInfo(importingFile, moduleSymbol, checker, compilerOptions); + if (defaultInfo && ts.skipAlias(defaultInfo.symbol, checker) === symbol) { + return { moduleSymbol: moduleSymbol, importKind: defaultInfo.kind, exportedSymbolIsTypeOnly: isTypeOnlySymbol(symbol, checker) }; + } + var named = checker.tryGetMemberInModuleExportsAndProperties(symbol.name, moduleSymbol); + if (named && ts.skipAlias(named, checker) === symbol) { + return { moduleSymbol: moduleSymbol, importKind: 0 /* Named */, exportedSymbolIsTypeOnly: isTypeOnlySymbol(symbol, checker) }; + } + } + } function getAllReExportingModules(importingFile, exportedSymbol, exportingModuleSymbol, symbolName, host, program, useAutoImportProvider) { var result = []; var compilerOptions = program.getCompilerOptions(); @@ -136644,7 +138656,7 @@ var ts; var addToExisting = tryAddToExistingImport(existingImports, position !== undefined && isTypeOnlyPosition(sourceFile, position)); // Don't bother providing an action to add a new import if we can add to an existing one. var addImport = addToExisting ? [addToExisting] : getFixesForAddImport(exportInfos, existingImports, program, sourceFile, position, preferTypeOnlyImport, useRequire, host, preferences); - return __spreadArrays((useNamespace ? [useNamespace] : ts.emptyArray), addImport); + return __spreadArray(__spreadArray([], (useNamespace ? [useNamespace] : ts.emptyArray)), addImport); } function tryUseExistingNamespaceImport(existingImports, symbolName, position, checker) { // It is possible that multiple import statements with the same specifier exist in the file. @@ -136760,10 +138772,9 @@ var ts; function getNewImportInfos(program, sourceFile, position, preferTypeOnlyImport, useRequire, moduleSymbols, host, preferences) { var isJs = ts.isSourceFileJS(sourceFile); var compilerOptions = program.getCompilerOptions(); - var allowsImportingSpecifier = createAutoImportFilter(sourceFile, program, host).allowsImportingSpecifier; - var choicesForEachExportingModule = ts.flatMap(moduleSymbols, function (_a) { + return ts.flatMap(moduleSymbols, function (_a) { var moduleSymbol = _a.moduleSymbol, importKind = _a.importKind, exportedSymbolIsTypeOnly = _a.exportedSymbolIsTypeOnly; - return ts.moduleSpecifiers.getModuleSpecifiers(moduleSymbol, compilerOptions, sourceFile, ts.createModuleSpecifierResolutionHost(program, host), preferences) + return ts.moduleSpecifiers.getModuleSpecifiers(moduleSymbol, program.getTypeChecker(), compilerOptions, sourceFile, ts.createModuleSpecifierResolutionHost(program, host), preferences) .map(function (moduleSpecifier) { // `position` should only be undefined at a missing jsx namespace, in which case we shouldn't be looking for pure types. return exportedSymbolIsTypeOnly && isJs @@ -136771,18 +138782,6 @@ var ts; : { kind: 3 /* AddNew */, moduleSpecifier: moduleSpecifier, importKind: importKind, useRequire: useRequire, typeOnly: preferTypeOnlyImport }; }); }); - // Sort by presence in package.json, then shortest paths first - return ts.sort(choicesForEachExportingModule, function (a, b) { - var allowsImportingA = allowsImportingSpecifier(a.moduleSpecifier); - var allowsImportingB = allowsImportingSpecifier(b.moduleSpecifier); - if (allowsImportingA && !allowsImportingB) { - return -1; - } - if (allowsImportingB && !allowsImportingA) { - return 1; - } - return a.moduleSpecifier.length - b.moduleSpecifier.length; - }); } function getFixesForAddImport(exportInfos, existingImports, program, sourceFile, position, preferTypeOnlyImport, useRequire, host, preferences) { var existingDeclaration = ts.firstDefined(existingImports, function (info) { return newImportInfoFromExistingSpecifier(info, preferTypeOnlyImport, useRequire); }); @@ -136803,7 +138802,28 @@ var ts; var info = errorCode === ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code ? getFixesInfoForUMDImport(context, symbolToken) : ts.isIdentifier(symbolToken) ? getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider) : undefined; - return info && __assign(__assign({}, info), { fixes: ts.sort(info.fixes, function (a, b) { return a.kind - b.kind; }) }); + return info && __assign(__assign({}, info), { fixes: sortFixes(info.fixes, context.sourceFile, context.program, context.host) }); + } + function sortFixes(fixes, sourceFile, program, host) { + var allowsImportingSpecifier = createAutoImportFilter(sourceFile, program, host).allowsImportingSpecifier; + return ts.sort(fixes, function (a, b) { return ts.compareValues(a.kind, b.kind) || compareModuleSpecifiers(a, b, allowsImportingSpecifier); }); + } + function getBestFix(fixes, sourceFile, program, host) { + // These will always be placed first if available, and are better than other kinds + if (fixes[0].kind === 0 /* UseNamespace */ || fixes[0].kind === 2 /* AddToExisting */) { + return fixes[0]; + } + var allowsImportingSpecifier = createAutoImportFilter(sourceFile, program, host).allowsImportingSpecifier; + return fixes.reduce(function (best, fix) { + return compareModuleSpecifiers(fix, best, allowsImportingSpecifier) === -1 /* LessThan */ ? fix : best; + }); + } + function compareModuleSpecifiers(a, b, allowsImportingSpecifier) { + if (a.kind !== 0 /* UseNamespace */ && b.kind !== 0 /* UseNamespace */) { + return ts.compareBooleans(allowsImportingSpecifier(a.moduleSpecifier), allowsImportingSpecifier(b.moduleSpecifier)) + || ts.compareNumberOfDirectorySeparators(a.moduleSpecifier, b.moduleSpecifier); + } + return 0 /* EqualTo */; } function getFixesInfoForUMDImport(_a, token) { var sourceFile = _a.sourceFile, program = _a.program, host = _a.host, preferences = _a.preferences; @@ -136910,7 +138930,7 @@ var ts; if (!exported) return undefined; var symbol = exported.symbol, kind = exported.kind; - var info = getDefaultExportInfoWorker(symbol, moduleSymbol, checker, compilerOptions); + var info = getDefaultExportInfoWorker(symbol, checker, compilerOptions); return info && __assign({ symbol: symbol, kind: kind }, info); } function getDefaultLikeExportWorker(importingFile, moduleSymbol, checker, compilerOptions) { @@ -136945,7 +138965,7 @@ var ts; // allowSyntheticDefaultImports/esModuleInterop is enabled. return allowSyntheticDefaults ? 1 /* Default */ : 3 /* CommonJS */; } - function getDefaultExportInfoWorker(defaultExport, moduleSymbol, checker, compilerOptions) { + function getDefaultExportInfoWorker(defaultExport, checker, compilerOptions) { var localSymbol = ts.getLocalSymbolForExportDefault(defaultExport); if (localSymbol) return { symbolForMeaning: localSymbol, name: localSymbol.name }; @@ -136959,21 +138979,20 @@ var ts; // but we can still offer completions for it. // - `aliased.parent` will be undefined if the module is exporting `globalThis.something`, // or another expression that resolves to a global. - return getDefaultExportInfoWorker(aliased, aliased.parent, checker, compilerOptions); + return getDefaultExportInfoWorker(aliased, checker, compilerOptions); } } if (defaultExport.escapedName !== "default" /* Default */ && defaultExport.escapedName !== "export=" /* ExportEquals */) { return { symbolForMeaning: defaultExport, name: defaultExport.getName() }; } - return { symbolForMeaning: defaultExport, name: moduleSymbolToValidIdentifier(moduleSymbol, compilerOptions.target) }; + return { symbolForMeaning: defaultExport, name: ts.getNameForExportedSymbol(defaultExport, compilerOptions.target) }; } function getNameForExportDefault(symbol) { return symbol.declarations && ts.firstDefined(symbol.declarations, function (declaration) { + var _a; if (ts.isExportAssignment(declaration)) { - if (ts.isIdentifier(declaration.expression)) { - return declaration.expression.text; - } + return (_a = ts.tryCast(ts.skipOuterExpressions(declaration.expression), ts.isIdentifier)) === null || _a === void 0 ? void 0 : _a.text; } else if (ts.isExportSpecifier(declaration)) { ts.Debug.assert(declaration.name.text === "default" /* Default */, "Expected the specifier to be a default export"); @@ -137102,7 +139121,7 @@ var ts; var declaration = namespaceLikeImport.importKind === 3 /* CommonJS */ ? ts.factory.createImportEqualsDeclaration( /*decorators*/ undefined, - /*modifiers*/ undefined, ts.factory.createIdentifier(namespaceLikeImport.name), ts.factory.createExternalModuleReference(quotedModuleSpecifier)) + /*modifiers*/ undefined, typeOnly, ts.factory.createIdentifier(namespaceLikeImport.name), ts.factory.createExternalModuleReference(quotedModuleSpecifier)) : ts.factory.createImportDeclaration( /*decorators*/ undefined, /*modifiers*/ undefined, ts.factory.createImportClause(typeOnly, @@ -137346,6 +139365,40 @@ var ts; })(ts || (ts = {})); /* @internal */ var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixNoPropertyAccessFromIndexSignature"; + var errorCodes = [ + ts.Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0.code + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + fixIds: [fixId], + getCodeActions: function (context) { + var sourceFile = context.sourceFile, span = context.span, preferences = context.preferences; + var property = getPropertyAccessExpression(sourceFile, span.start); + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, context.sourceFile, property, preferences); }); + return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Use_element_access_for_0, property.name.text], fixId, ts.Diagnostics.Use_element_access_for_all_undeclared_properties)]; + }, + getAllCodeActions: function (context) { + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return doChange(changes, diag.file, getPropertyAccessExpression(diag.file, diag.start), context.preferences); }); + } + }); + function doChange(changes, sourceFile, node, preferences) { + var quotePreference = ts.getQuotePreference(sourceFile, preferences); + var argumentsExpression = ts.factory.createStringLiteral(node.name.text, quotePreference === 0 /* Single */); + changes.replaceNode(sourceFile, node, ts.isPropertyAccessChain(node) ? + ts.factory.createElementAccessChain(node.expression, node.questionDotToken, argumentsExpression) : + ts.factory.createElementAccessExpression(node.expression, argumentsExpression)); + } + function getPropertyAccessExpression(sourceFile, pos) { + return ts.cast(ts.getTokenAtPosition(sourceFile, pos).parent, ts.isPropertyAccessExpression); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; (function (ts) { var codefix; (function (codefix) { @@ -137789,32 +139842,37 @@ var ts; (function (ts) { var codefix; (function (codefix) { - var fixName = "addMissingMember"; + var fixMissingMember = "fixMissingMember"; + var fixMissingFunctionDeclaration = "fixMissingFunctionDeclaration"; var errorCodes = [ ts.Diagnostics.Property_0_does_not_exist_on_type_1.code, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code, ts.Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2.code, ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2.code, - ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more.code + ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more.code, + ts.Diagnostics.Cannot_find_name_0.code ]; - var fixId = "addMissingMember"; codefix.registerCodeFix({ errorCodes: errorCodes, getCodeActions: function (context) { - var info = getInfo(context.sourceFile, context.span.start, context.program.getTypeChecker(), context.program); + var typeChecker = context.program.getTypeChecker(); + var info = getInfo(context.sourceFile, context.span.start, typeChecker, context.program); if (!info) { return undefined; } + if (info.kind === 2 /* Function */) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addFunctionDeclaration(t, context, info); }); + return [codefix.createCodeFixAction(fixMissingFunctionDeclaration, changes, [ts.Diagnostics.Add_missing_function_declaration_0, info.token.text], fixMissingFunctionDeclaration, ts.Diagnostics.Add_all_missing_function_declarations)]; + } if (info.kind === 0 /* Enum */) { - var token_1 = info.token, parentDeclaration_1 = info.parentDeclaration; - var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addEnumMemberDeclaration(t, context.program.getTypeChecker(), token_1, parentDeclaration_1); }); - return [codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Add_missing_enum_member_0, token_1.text], fixId, ts.Diagnostics.Add_all_missing_members)]; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addEnumMemberDeclaration(t, context.program.getTypeChecker(), info); }); + return [codefix.createCodeFixAction(fixMissingMember, changes, [ts.Diagnostics.Add_missing_enum_member_0, info.token.text], fixMissingMember, ts.Diagnostics.Add_all_missing_members)]; } return ts.concatenate(getActionsForMissingMethodDeclaration(context, info), getActionsForMissingMemberDeclaration(context, info)); }, - fixIds: [fixId], + fixIds: [fixMissingMember, fixMissingFunctionDeclaration], getAllCodeActions: function (context) { - var program = context.program; + var program = context.program, fixId = context.fixId; var checker = program.getTypeChecker(); var seen = new ts.Map(); var typeDeclToMembers = new ts.Map(); @@ -137824,15 +139882,22 @@ var ts; if (!info || !ts.addToSeen(seen, ts.getNodeId(info.parentDeclaration) + "#" + info.token.text)) { return; } - if (info.kind === 0 /* Enum */) { - var token = info.token, parentDeclaration = info.parentDeclaration; - addEnumMemberDeclaration(changes, checker, token, parentDeclaration); + if (fixId === fixMissingFunctionDeclaration) { + if (info.kind === 2 /* Function */) { + addFunctionDeclaration(changes, context, info); + } } else { - var parentDeclaration = info.parentDeclaration, token_2 = info.token; - var infos = ts.getOrUpdate(typeDeclToMembers, parentDeclaration, function () { return []; }); - if (!infos.some(function (i) { return i.token.text === token_2.text; })) - infos.push(info); + if (info.kind === 0 /* Enum */) { + addEnumMemberDeclaration(changes, checker, info); + } + if (info.kind === 1 /* ClassOrInterface */) { + var parentDeclaration = info.parentDeclaration, token_1 = info.token; + var infos = ts.getOrUpdate(typeDeclToMembers, parentDeclaration, function () { return []; }); + if (!infos.some(function (i) { return i.token.text === token_1.text; })) { + infos.push(info); + } + } } }); typeDeclToMembers.forEach(function (infos, classDeclaration) { @@ -137850,7 +139915,7 @@ var ts; var parentDeclaration = info.parentDeclaration, declSourceFile = info.declSourceFile, modifierFlags = info.modifierFlags, token = info.token, call = info.call, isJSFile = info.isJSFile; // Always prefer to add a method declaration if possible. if (call && !ts.isPrivateIdentifier(token)) { - addMethodDeclaration(context, changes, call, token.text, modifierFlags & 32 /* Static */, parentDeclaration, declSourceFile, isJSFile); + addMethodDeclaration(context, changes, call, token, modifierFlags & 32 /* Static */, parentDeclaration, declSourceFile); } else { if (isJSFile && !ts.isInterfaceDeclaration(parentDeclaration)) { @@ -137874,22 +139939,42 @@ var ts; (function (InfoKind) { InfoKind[InfoKind["Enum"] = 0] = "Enum"; InfoKind[InfoKind["ClassOrInterface"] = 1] = "ClassOrInterface"; + InfoKind[InfoKind["Function"] = 2] = "Function"; })(InfoKind || (InfoKind = {})); - function getInfo(tokenSourceFile, tokenPos, checker, program) { + function getInfo(sourceFile, tokenPos, checker, program) { // The identifier of the missing property. eg: // this.missing = 1; // ^^^^^^^ - var token = ts.getTokenAtPosition(tokenSourceFile, tokenPos); + var token = ts.getTokenAtPosition(sourceFile, tokenPos); if (!ts.isIdentifier(token) && !ts.isPrivateIdentifier(token)) { return undefined; } var parent = token.parent; - if (!ts.isPropertyAccessExpression(parent)) + if (ts.isIdentifier(token) && ts.isCallExpression(parent)) { + return { kind: 2 /* Function */, token: token, call: parent, sourceFile: sourceFile, modifierFlags: 0 /* None */, parentDeclaration: sourceFile }; + } + if (!ts.isPropertyAccessExpression(parent)) { return undefined; + } var leftExpressionType = ts.skipConstraint(checker.getTypeAtLocation(parent.expression)); var symbol = leftExpressionType.symbol; - if (!symbol || !symbol.declarations) + if (!symbol || !symbol.declarations) { return undefined; + } + if (ts.isIdentifier(token) && ts.isCallExpression(parent.parent)) { + var moduleDeclaration = ts.find(symbol.declarations, ts.isModuleDeclaration); + var moduleDeclarationSourceFile = moduleDeclaration === null || moduleDeclaration === void 0 ? void 0 : moduleDeclaration.getSourceFile(); + if (moduleDeclaration && moduleDeclarationSourceFile && !program.isSourceFileFromExternalLibrary(moduleDeclarationSourceFile)) { + return { kind: 2 /* Function */, token: token, call: parent.parent, sourceFile: sourceFile, modifierFlags: 1 /* Export */, parentDeclaration: moduleDeclaration }; + } + var moduleSourceFile = ts.find(symbol.declarations, ts.isSourceFile); + if (sourceFile.commonJsModuleIndicator) { + return; + } + if (moduleSourceFile && !program.isSourceFileFromExternalLibrary(moduleSourceFile)) { + return { kind: 2 /* Function */, token: token, call: parent.parent, sourceFile: moduleSourceFile, modifierFlags: 1 /* Export */, parentDeclaration: moduleSourceFile }; + } + } var classDeclaration = ts.find(symbol.declarations, ts.isClassLike); // Don't suggest adding private identifiers to anything other than a class. if (!classDeclaration && ts.isPrivateIdentifier(token)) { @@ -137929,7 +140014,7 @@ var ts; } var diagnostic = modifierFlags & 32 /* Static */ ? ts.Diagnostics.Initialize_static_property_0 : ts.isPrivateIdentifier(token) ? ts.Diagnostics.Declare_a_private_field_named_0 : ts.Diagnostics.Initialize_property_0_in_the_constructor; - return codefix.createCodeFixAction(fixName, changes, [diagnostic, token.text], fixId, ts.Diagnostics.Add_all_missing_members); + return codefix.createCodeFixAction(fixMissingMember, changes, [diagnostic, token.text], fixMissingMember, ts.Diagnostics.Add_all_missing_members); } function addMissingMemberInJs(changeTracker, declSourceFile, classDeclaration, token, makeStatic) { var tokenName = token.text; @@ -137974,12 +140059,12 @@ var ts; var isStatic = modifierFlags & 32 /* Static */; var typeNode = getTypeNode(context.program.getTypeChecker(), parentDeclaration, token); var addPropertyDeclarationChanges = function (modifierFlags) { return ts.textChanges.ChangeTracker.with(context, function (t) { return addPropertyDeclaration(t, declSourceFile, parentDeclaration, memberName, typeNode, modifierFlags); }); }; - var actions = [codefix.createCodeFixAction(fixName, addPropertyDeclarationChanges(modifierFlags & 32 /* Static */), [isStatic ? ts.Diagnostics.Declare_static_property_0 : ts.Diagnostics.Declare_property_0, memberName], fixId, ts.Diagnostics.Add_all_missing_members)]; + var actions = [codefix.createCodeFixAction(fixMissingMember, addPropertyDeclarationChanges(modifierFlags & 32 /* Static */), [isStatic ? ts.Diagnostics.Declare_static_property_0 : ts.Diagnostics.Declare_property_0, memberName], fixMissingMember, ts.Diagnostics.Add_all_missing_members)]; if (isStatic || ts.isPrivateIdentifier(token)) { return actions; } if (modifierFlags & 8 /* Private */) { - actions.unshift(codefix.createCodeFixActionWithoutFixAll(fixName, addPropertyDeclarationChanges(8 /* Private */), [ts.Diagnostics.Declare_private_property_0, memberName])); + actions.unshift(codefix.createCodeFixActionWithoutFixAll(fixMissingMember, addPropertyDeclarationChanges(8 /* Private */), [ts.Diagnostics.Declare_private_property_0, memberName])); } actions.push(createAddIndexSignatureAction(context, declSourceFile, parentDeclaration, token.text, typeNode)); return actions; @@ -138037,10 +140122,10 @@ var ts; /*modifiers*/ undefined, [indexingParameter], typeNode); var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return t.insertNodeAtClassStart(declSourceFile, classDeclaration, indexSignature); }); // No fixId here because code-fix-all currently only works on adding individual named properties. - return codefix.createCodeFixActionWithoutFixAll(fixName, changes, [ts.Diagnostics.Add_index_signature_for_property_0, tokenName]); + return codefix.createCodeFixActionWithoutFixAll(fixMissingMember, changes, [ts.Diagnostics.Add_index_signature_for_property_0, tokenName]); } function getActionsForMissingMethodDeclaration(context, info) { - var parentDeclaration = info.parentDeclaration, declSourceFile = info.declSourceFile, modifierFlags = info.modifierFlags, token = info.token, call = info.call, isJSFile = info.isJSFile; + var parentDeclaration = info.parentDeclaration, declSourceFile = info.declSourceFile, modifierFlags = info.modifierFlags, token = info.token, call = info.call; if (call === undefined) { return undefined; } @@ -138049,16 +140134,16 @@ var ts; return undefined; } var methodName = token.text; - var addMethodDeclarationChanges = function (modifierFlags) { return ts.textChanges.ChangeTracker.with(context, function (t) { return addMethodDeclaration(context, t, call, methodName, modifierFlags, parentDeclaration, declSourceFile, isJSFile); }); }; - var actions = [codefix.createCodeFixAction(fixName, addMethodDeclarationChanges(modifierFlags & 32 /* Static */), [modifierFlags & 32 /* Static */ ? ts.Diagnostics.Declare_static_method_0 : ts.Diagnostics.Declare_method_0, methodName], fixId, ts.Diagnostics.Add_all_missing_members)]; + var addMethodDeclarationChanges = function (modifierFlags) { return ts.textChanges.ChangeTracker.with(context, function (t) { return addMethodDeclaration(context, t, call, token, modifierFlags, parentDeclaration, declSourceFile); }); }; + var actions = [codefix.createCodeFixAction(fixMissingMember, addMethodDeclarationChanges(modifierFlags & 32 /* Static */), [modifierFlags & 32 /* Static */ ? ts.Diagnostics.Declare_static_method_0 : ts.Diagnostics.Declare_method_0, methodName], fixMissingMember, ts.Diagnostics.Add_all_missing_members)]; if (modifierFlags & 8 /* Private */) { - actions.unshift(codefix.createCodeFixActionWithoutFixAll(fixName, addMethodDeclarationChanges(8 /* Private */), [ts.Diagnostics.Declare_private_method_0, methodName])); + actions.unshift(codefix.createCodeFixActionWithoutFixAll(fixMissingMember, addMethodDeclarationChanges(8 /* Private */), [ts.Diagnostics.Declare_private_method_0, methodName])); } return actions; } - function addMethodDeclaration(context, changes, callExpression, methodName, modifierFlags, parentDeclaration, sourceFile, isJSFile) { + function addMethodDeclaration(context, changes, callExpression, name, modifierFlags, parentDeclaration, sourceFile) { var importAdder = codefix.createImportAdder(sourceFile, context.program, context.preferences, context.host); - var methodDeclaration = codefix.createMethodFromCallExpression(context, importAdder, callExpression, methodName, modifierFlags, parentDeclaration, isJSFile); + var methodDeclaration = codefix.createSignatureDeclarationFromCallExpression(165 /* MethodDeclaration */, context, importAdder, callExpression, name, modifierFlags, parentDeclaration); var containingMethodDeclaration = ts.findAncestor(callExpression, function (n) { return ts.isMethodDeclaration(n) || ts.isConstructorDeclaration(n); }); if (containingMethodDeclaration && containingMethodDeclaration.parent === parentDeclaration) { changes.insertNodeAfter(sourceFile, containingMethodDeclaration, methodDeclaration); @@ -138068,22 +140153,28 @@ var ts; } importAdder.writeFixes(changes); } - function addEnumMemberDeclaration(changes, checker, token, enumDeclaration) { + function addEnumMemberDeclaration(changes, checker, _a) { + var token = _a.token, parentDeclaration = _a.parentDeclaration; /** * create initializer only literal enum that has string initializer. * value of initializer is a string literal that equal to name of enum member. * numeric enum or empty enum will not create initializer. */ - var hasStringInitializer = ts.some(enumDeclaration.members, function (member) { + var hasStringInitializer = ts.some(parentDeclaration.members, function (member) { var type = checker.getTypeAtLocation(member); return !!(type && type.flags & 402653316 /* StringLike */); }); var enumMember = ts.factory.createEnumMember(token, hasStringInitializer ? ts.factory.createStringLiteral(token.text) : undefined); - changes.replaceNode(enumDeclaration.getSourceFile(), enumDeclaration, ts.factory.updateEnumDeclaration(enumDeclaration, enumDeclaration.decorators, enumDeclaration.modifiers, enumDeclaration.name, ts.concatenate(enumDeclaration.members, ts.singleElementArray(enumMember))), { + changes.replaceNode(parentDeclaration.getSourceFile(), parentDeclaration, ts.factory.updateEnumDeclaration(parentDeclaration, parentDeclaration.decorators, parentDeclaration.modifiers, parentDeclaration.name, ts.concatenate(parentDeclaration.members, ts.singleElementArray(enumMember))), { leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll, trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Exclude }); } + function addFunctionDeclaration(changes, context, info) { + var importAdder = codefix.createImportAdder(context.sourceFile, context.program, context.preferences, context.host); + var functionDeclaration = codefix.createSignatureDeclarationFromCallExpression(251 /* FunctionDeclaration */, context, importAdder, info.call, ts.idText(info.token), info.modifierFlags, info.parentDeclaration); + changes.insertNodeAtEndOfScope(info.sourceFile, info.parentDeclaration, functionDeclaration); + } })(codefix = ts.codefix || (ts.codefix = {})); })(ts || (ts = {})); /* @internal */ @@ -138173,9 +140264,10 @@ var ts; return ts.isExternalModuleNameRelative(packageName) ? undefined : packageName; } function getTypesPackageNameToInstall(packageName, host, diagCode) { + var _a; return diagCode === errorCodeCannotFindModule ? (ts.JsTyping.nodeCoreModules.has(packageName) ? "@types/node" : undefined) - : (host.isKnownTypesPackageName(packageName) ? ts.getTypesPackageName(packageName) : undefined); // TODO: GH#18217 + : (((_a = host.isKnownTypesPackageName) === null || _a === void 0 ? void 0 : _a.call(host, packageName)) ? ts.getTypesPackageName(packageName) : undefined); } })(codefix = ts.codefix || (ts.codefix = {})); })(ts || (ts = {})); @@ -138397,7 +140489,10 @@ var ts; var codefix; (function (codefix) { codefix.registerCodeFix({ - errorCodes: [ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_the_target_option_is_set_to_es2017_or_higher.code], + errorCodes: [ + ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_the_target_option_is_set_to_es2017_or_higher.code, + ts.Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_the_target_option_is_set_to_es2017_or_higher.code, + ], getCodeActions: function (context) { var compilerOptions = context.program.getCompilerOptions(); var configFile = compilerOptions.configFile; @@ -138613,6 +140708,7 @@ var ts; var fixName = "unusedIdentifier"; var fixIdPrefix = "unusedIdentifier_prefix"; var fixIdDelete = "unusedIdentifier_delete"; + var fixIdDeleteImports = "unusedIdentifier_deleteImports"; var fixIdInfer = "unusedIdentifier_infer"; var errorCodes = [ ts.Diagnostics._0_is_declared_but_its_value_is_never_read.code, @@ -138626,7 +140722,7 @@ var ts; codefix.registerCodeFix({ errorCodes: errorCodes, getCodeActions: function (context) { - var errorCode = context.errorCode, sourceFile = context.sourceFile, program = context.program; + var errorCode = context.errorCode, sourceFile = context.sourceFile, program = context.program, cancellationToken = context.cancellationToken; var checker = program.getTypeChecker(); var sourceFiles = program.getSourceFiles(); var token = ts.getTokenAtPosition(sourceFile, context.span.start); @@ -138640,9 +140736,15 @@ var ts; var importDecl = tryGetFullImport(token); if (importDecl) { var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return t.delete(sourceFile, importDecl); }); - return [createDeleteFix(changes, [ts.Diagnostics.Remove_import_from_0, ts.showModuleSpecifier(importDecl)])]; + return [codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Remove_import_from_0, ts.showModuleSpecifier(importDecl)], fixIdDeleteImports, ts.Diagnostics.Delete_all_unused_imports)]; } - if (ts.isObjectBindingPattern(token.parent)) { + else if (isImport(token)) { + var deletion = ts.textChanges.ChangeTracker.with(context, function (t) { return tryDeleteDeclaration(sourceFile, token, t, checker, sourceFiles, program, cancellationToken, /*isFixAll*/ false); }); + if (deletion.length) { + return [codefix.createCodeFixAction(fixName, deletion, [ts.Diagnostics.Remove_unused_declaration_for_Colon_0, token.getText(sourceFile)], fixIdDeleteImports, ts.Diagnostics.Delete_all_unused_imports)]; + } + } + if (ts.isObjectBindingPattern(token.parent) || ts.isArrayBindingPattern(token.parent)) { if (ts.isParameter(token.parent.parent)) { var elements = token.parent.elements; var diagnostic = [ @@ -138676,7 +140778,7 @@ var ts; } else { var deletion = ts.textChanges.ChangeTracker.with(context, function (t) { - return tryDeleteDeclaration(sourceFile, token, t, checker, sourceFiles, /*isFixAll*/ false); + return tryDeleteDeclaration(sourceFile, token, t, checker, sourceFiles, program, cancellationToken, /*isFixAll*/ false); }); if (deletion.length) { var name = ts.isComputedPropertyName(token.parent) ? token.parent : token; @@ -138689,9 +140791,9 @@ var ts; } return result; }, - fixIds: [fixIdPrefix, fixIdDelete, fixIdInfer], + fixIds: [fixIdPrefix, fixIdDelete, fixIdDeleteImports, fixIdInfer], getAllCodeActions: function (context) { - var sourceFile = context.sourceFile, program = context.program; + var sourceFile = context.sourceFile, program = context.program, cancellationToken = context.cancellationToken; var checker = program.getTypeChecker(); var sourceFiles = program.getSourceFiles(); return codefix.codeFixAll(context, errorCodes, function (changes, diag) { @@ -138700,14 +140802,20 @@ var ts; case fixIdPrefix: tryPrefixDeclaration(changes, diag.code, sourceFile, token); break; - case fixIdDelete: { - if (token.kind === 135 /* InferKeyword */) { - break; // Can't delete - } + case fixIdDeleteImports: { var importDecl = tryGetFullImport(token); if (importDecl) { changes.delete(sourceFile, importDecl); } + else if (isImport(token)) { + tryDeleteDeclaration(sourceFile, token, changes, checker, sourceFiles, program, cancellationToken, /*isFixAll*/ true); + } + break; + } + case fixIdDelete: { + if (token.kind === 135 /* InferKeyword */ || isImport(token)) { + break; // Can't delete + } else if (ts.isJSDocTemplateTag(token)) { changes.delete(sourceFile, token); } @@ -138715,18 +140823,21 @@ var ts; deleteTypeParameters(changes, sourceFile, token); } else if (ts.isObjectBindingPattern(token.parent)) { - if (ts.isParameter(token.parent.parent)) { - deleteDestructuringElements(changes, sourceFile, token.parent); + if (token.parent.parent.initializer) { + break; } - else { + else if (!ts.isParameter(token.parent.parent) || isNotProvidedArguments(token.parent.parent, checker, sourceFiles)) { changes.delete(sourceFile, token.parent.parent); } } + else if (ts.isArrayBindingPattern(token.parent.parent) && token.parent.parent.parent.initializer) { + break; + } else if (canDeleteEntireVariableStatement(sourceFile, token)) { deleteEntireVariableStatement(changes, sourceFile, token.parent); } else { - tryDeleteDeclaration(sourceFile, token, changes, checker, sourceFiles, /*isFixAll*/ true); + tryDeleteDeclaration(sourceFile, token, changes, checker, sourceFiles, program, cancellationToken, /*isFixAll*/ true); } break; } @@ -138750,7 +140861,11 @@ var ts; function deleteTypeParameters(changes, sourceFile, token) { changes.delete(sourceFile, ts.Debug.checkDefined(ts.cast(token.parent, ts.isDeclarationWithTypeParameterChildren).typeParameters, "The type parameter to delete should exist")); } - // Sometimes the diagnostic span is an entire ImportDeclaration, so we should remove the whole thing. + function isImport(token) { + return token.kind === 99 /* ImportKeyword */ + || token.kind === 78 /* Identifier */ && (token.parent.kind === 265 /* ImportSpecifier */ || token.parent.kind === 262 /* ImportClause */); + } + /** Sometimes the diagnostic span is an entire ImportDeclaration, so we should remove the whole thing. */ function tryGetFullImport(token) { return token.kind === 99 /* ImportKeyword */ ? ts.tryCast(token.parent, ts.isImportDeclaration) : undefined; } @@ -138797,52 +140912,77 @@ var ts; } return false; } - function tryDeleteDeclaration(sourceFile, token, changes, checker, sourceFiles, isFixAll) { - tryDeleteDeclarationWorker(token, changes, sourceFile, checker, sourceFiles, isFixAll); - if (ts.isIdentifier(token)) - deleteAssignments(changes, sourceFile, token, checker); - } - function deleteAssignments(changes, sourceFile, token, checker) { - ts.FindAllReferences.Core.eachSymbolReferenceInFile(token, checker, sourceFile, function (ref) { - if (ts.isPropertyAccessExpression(ref.parent) && ref.parent.name === ref) - ref = ref.parent; - if (ts.isBinaryExpression(ref.parent) && ts.isExpressionStatement(ref.parent.parent) && ref.parent.left === ref) { - changes.delete(sourceFile, ref.parent.parent); - } - }); + function tryDeleteDeclaration(sourceFile, token, changes, checker, sourceFiles, program, cancellationToken, isFixAll) { + tryDeleteDeclarationWorker(token, changes, sourceFile, checker, sourceFiles, program, cancellationToken, isFixAll); + if (ts.isIdentifier(token)) { + ts.FindAllReferences.Core.eachSymbolReferenceInFile(token, checker, sourceFile, function (ref) { + if (ts.isPropertyAccessExpression(ref.parent) && ref.parent.name === ref) + ref = ref.parent; + if (!isFixAll && mayDeleteExpression(ref)) { + changes.delete(sourceFile, ref.parent.parent); + } + }); + } } - function tryDeleteDeclarationWorker(token, changes, sourceFile, checker, sourceFiles, isFixAll) { + function tryDeleteDeclarationWorker(token, changes, sourceFile, checker, sourceFiles, program, cancellationToken, isFixAll) { var parent = token.parent; if (ts.isParameter(parent)) { - tryDeleteParameter(changes, sourceFile, parent, checker, sourceFiles, isFixAll); + tryDeleteParameter(changes, sourceFile, parent, checker, sourceFiles, program, cancellationToken, isFixAll); } - else { + else if (!isFixAll || !(ts.isIdentifier(token) && ts.FindAllReferences.Core.isSymbolReferencedInFile(token, checker, sourceFile))) { changes.delete(sourceFile, ts.isImportClause(parent) ? token : ts.isComputedPropertyName(parent) ? parent.parent : parent); } } - function tryDeleteParameter(changes, sourceFile, p, checker, sourceFiles, isFixAll) { + function tryDeleteParameter(changes, sourceFile, parameter, checker, sourceFiles, program, cancellationToken, isFixAll) { if (isFixAll === void 0) { isFixAll = false; } - if (mayDeleteParameter(checker, sourceFile, p, isFixAll)) { - if (p.modifiers && p.modifiers.length > 0 && - (!ts.isIdentifier(p.name) || ts.FindAllReferences.Core.isSymbolReferencedInFile(p.name, checker, sourceFile))) { - p.modifiers.forEach(function (modifier) { return changes.deleteModifier(sourceFile, modifier); }); + if (mayDeleteParameter(checker, sourceFile, parameter, sourceFiles, program, cancellationToken, isFixAll)) { + if (parameter.modifiers && parameter.modifiers.length > 0 && + (!ts.isIdentifier(parameter.name) || ts.FindAllReferences.Core.isSymbolReferencedInFile(parameter.name, checker, sourceFile))) { + parameter.modifiers.forEach(function (modifier) { return changes.deleteModifier(sourceFile, modifier); }); } - else { - changes.delete(sourceFile, p); - deleteUnusedArguments(changes, sourceFile, p, sourceFiles, checker); + else if (!parameter.initializer && isNotProvidedArguments(parameter, checker, sourceFiles)) { + changes.delete(sourceFile, parameter); } } } - function mayDeleteParameter(checker, sourceFile, parameter, isFixAll) { + function isNotProvidedArguments(parameter, checker, sourceFiles) { + var index = parameter.parent.parameters.indexOf(parameter); + // Just in case the call didn't provide enough arguments. + return !ts.FindAllReferences.Core.someSignatureUsage(parameter.parent, sourceFiles, checker, function (_, call) { return !call || call.arguments.length > index; }); + } + function mayDeleteParameter(checker, sourceFile, parameter, sourceFiles, program, cancellationToken, isFixAll) { var parent = parameter.parent; switch (parent.kind) { case 165 /* MethodDeclaration */: - // Don't remove a parameter if this overrides something. - var symbol = checker.getSymbolAtLocation(parent.name); - if (ts.isMemberSymbolInBaseType(symbol, checker)) - return false; - // falls through case 166 /* Constructor */: + var index = parent.parameters.indexOf(parameter); + var referent = ts.isMethodDeclaration(parent) ? parent.name : parent; + var entries = ts.FindAllReferences.Core.getReferencedSymbolsForNode(parent.pos, referent, program, sourceFiles, cancellationToken); + if (entries) { + for (var _i = 0, entries_2 = entries; _i < entries_2.length; _i++) { + var entry = entries_2[_i]; + for (var _a = 0, _b = entry.references; _a < _b.length; _a++) { + var reference = _b[_a]; + if (reference.kind === 1 /* Node */) { + // argument in super(...) + var isSuperCall_1 = ts.isSuperKeyword(reference.node) + && ts.isCallExpression(reference.node.parent) + && reference.node.parent.arguments.length > index; + // argument in super.m(...) + var isSuperMethodCall = ts.isPropertyAccessExpression(reference.node.parent) + && ts.isSuperKeyword(reference.node.parent.expression) + && ts.isCallExpression(reference.node.parent.parent) + && reference.node.parent.parent.arguments.length > index; + // parameter in overridden or overriding method + var isOverriddenMethod = (ts.isMethodDeclaration(reference.node.parent) || ts.isMethodSignature(reference.node.parent)) + && reference.node.parent !== parameter.parent + && reference.node.parent.parameters.length > index; + if (isSuperCall_1 || isSuperMethodCall || isOverriddenMethod) + return false; + } + } + } + } return true; case 251 /* FunctionDeclaration */: { if (parent.name && isCallbackLike(checker, sourceFile, parent.name)) { @@ -138861,14 +141001,6 @@ var ts; return ts.Debug.failBadSyntaxKind(parent); } } - function deleteUnusedArguments(changes, sourceFile, deletedParameter, sourceFiles, checker) { - ts.FindAllReferences.Core.eachSignatureCall(deletedParameter.parent, sourceFiles, checker, function (call) { - var index = deletedParameter.parent.parameters.indexOf(deletedParameter); - if (call.arguments.length > index) { // Just in case the call didn't provide enough arguments. - changes.delete(sourceFile, call.arguments[index]); - } - }); - } function isCallbackLike(checker, sourceFile, name) { return !!ts.FindAllReferences.Core.eachSymbolReferenceInFile(name, checker, sourceFile, function (reference) { return ts.isIdentifier(reference) && ts.isCallExpression(reference.parent) && reference.parent.arguments.indexOf(reference) >= 0; @@ -138882,6 +141014,10 @@ var ts; parameters.slice(index + 1).every(function (p) { return ts.isIdentifier(p.name) && !p.symbol.isReferenced; }) : index === parameters.length - 1; } + function mayDeleteExpression(node) { + return ((ts.isBinaryExpression(node.parent) && node.parent.left === node) || + ((ts.isPostfixUnaryExpression(node.parent) || ts.isPrefixUnaryExpression(node.parent)) && node.parent.operand === node)) && ts.isExpressionStatement(node.parent.parent); + } })(codefix = ts.codefix || (ts.codefix = {})); })(ts || (ts = {})); /* @internal */ @@ -139114,7 +141250,7 @@ var ts; var fixId = "fixAwaitInSyncFunction"; var errorCodes = [ ts.Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, - ts.Diagnostics.A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator.code, + ts.Diagnostics.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, ]; codefix.registerCodeFix({ errorCodes: errorCodes, @@ -139522,17 +141658,44 @@ var ts; if (!signature) { return; } - var paramTags = ts.mapDefined(parameterInferences, function (inference) { + var inferences = ts.mapDefined(parameterInferences, function (inference) { var param = inference.declaration; // only infer parameters that have (1) no type and (2) an accessible inferred type - if (param.initializer || ts.getJSDocType(param) || !ts.isIdentifier(param.name)) + if (param.initializer || ts.getJSDocType(param) || !ts.isIdentifier(param.name)) { return; + } var typeNode = inference.type && ts.getTypeNodeIfAccessible(inference.type, param, program, host); - var name = ts.factory.cloneNode(param.name); - ts.setEmitFlags(name, 1536 /* NoComments */ | 2048 /* NoNestedComments */); - return typeNode && ts.factory.createJSDocParameterTag(/*tagName*/ undefined, name, /*isBracketed*/ !!inference.isOptional, ts.factory.createJSDocTypeExpression(typeNode), /* isNameFirst */ false, ""); + if (typeNode) { + var name = ts.factory.cloneNode(param.name); + ts.setEmitFlags(name, 1536 /* NoComments */ | 2048 /* NoNestedComments */); + return { name: ts.factory.cloneNode(param.name), param: param, isOptional: !!inference.isOptional, typeNode: typeNode }; + } }); - addJSDocTags(changes, sourceFile, signature, paramTags); + if (!inferences.length) { + return; + } + if (ts.isArrowFunction(signature) || ts.isFunctionExpression(signature)) { + var needParens = ts.isArrowFunction(signature) && !ts.findChildOfKind(signature, 20 /* OpenParenToken */, sourceFile); + if (needParens) { + changes.insertNodeBefore(sourceFile, ts.first(signature.parameters), ts.factory.createToken(20 /* OpenParenToken */)); + } + ts.forEach(inferences, function (_a) { + var typeNode = _a.typeNode, param = _a.param; + var typeTag = ts.factory.createJSDocTypeTag(/*tagName*/ undefined, ts.factory.createJSDocTypeExpression(typeNode)); + var jsDoc = ts.factory.createJSDocComment(/*comment*/ undefined, [typeTag]); + changes.insertNodeAt(sourceFile, param.getStart(sourceFile), jsDoc, { suffix: " " }); + }); + if (needParens) { + changes.insertNodeAfter(sourceFile, ts.last(signature.parameters), ts.factory.createToken(21 /* CloseParenToken */)); + } + } + else { + var paramTags = ts.map(inferences, function (_a) { + var name = _a.name, typeNode = _a.typeNode, isOptional = _a.isOptional; + return ts.factory.createJSDocParameterTag(/*tagName*/ undefined, name, /*isBracketed*/ !!isOptional, ts.factory.createJSDocTypeExpression(typeNode), /* isNameFirst */ false, ""); + }); + addJSDocTags(changes, sourceFile, signature, paramTags); + } } function addJSDocTags(changes, sourceFile, parent, newTags) { var comments = ts.mapDefined(parent.jsDoc, function (j) { return j.comment; }); @@ -139543,7 +141706,7 @@ var ts; oldTags[i] = merged; return !!merged; }); }); - var tag = ts.factory.createJSDocComment(comments.join("\n"), ts.factory.createNodeArray(__spreadArrays((oldTags || ts.emptyArray), unmergedNewTags))); + var tag = ts.factory.createJSDocComment(comments.join("\n"), ts.factory.createNodeArray(__spreadArray(__spreadArray([], (oldTags || ts.emptyArray)), unmergedNewTags))); var jsDocNode = parent.kind === 209 /* ArrowFunction */ ? getJsDocNodeForArrowFunction(parent) : parent; jsDocNode.jsDoc = parent.jsDoc; jsDocNode.jsDocCache = parent.jsDocCache; @@ -139599,12 +141762,13 @@ var ts; case 209 /* ArrowFunction */: case 208 /* FunctionExpression */: var parent = containingFunction.parent; - searchToken = ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name) ? + searchToken = (ts.isVariableDeclaration(parent) || ts.isPropertyDeclaration(parent)) && ts.isIdentifier(parent.name) ? parent.name : containingFunction.name; break; case 251 /* FunctionDeclaration */: case 165 /* MethodDeclaration */: + case 164 /* MethodSignature */: searchToken = containingFunction.name; break; } @@ -139675,7 +141839,7 @@ var ts; numberIndex: ts.forEach(usages, function (u) { return u.numberIndex; }), stringIndex: ts.forEach(usages, function (u) { return u.stringIndex; }), candidateThisTypes: ts.flatMap(usages, function (u) { return u.candidateThisTypes; }), - inferredTypes: undefined, + inferredTypes: undefined, // clear type cache }; } function single() { @@ -139686,12 +141850,12 @@ var ts; return undefined; } var usage = createEmptyUsage(); - for (var _i = 0, references_2 = references; _i < references_2.length; _i++) { - var reference = references_2[_i]; + for (var _i = 0, references_3 = references; _i < references_3.length; _i++) { + var reference = references_3[_i]; cancellationToken.throwIfCancellationRequested(); calculateUsageOfNode(reference, usage); } - var calls = __spreadArrays(usage.constructs || [], usage.calls || []); + var calls = __spreadArray(__spreadArray([], usage.constructs || []), usage.calls || []); return declaration.parameters.map(function (parameter, parameterIndex) { var types = []; var isRest = ts.isRestParameter(parameter); @@ -139725,8 +141889,8 @@ var ts; } function thisParameter() { var usage = createEmptyUsage(); - for (var _i = 0, references_3 = references; _i < references_3.length; _i++) { - var reference = references_3[_i]; + for (var _i = 0, references_4 = references; _i < references_4.length; _i++) { + var reference = references_4[_i]; cancellationToken.throwIfCancellationRequested(); calculateUsageOfNode(reference, usage); } @@ -139734,8 +141898,8 @@ var ts; } function inferTypesFromReferencesSingle(references) { var usage = createEmptyUsage(); - for (var _i = 0, references_4 = references; _i < references_4.length; _i++) { - var reference = references_4[_i]; + for (var _i = 0, references_5 = references; _i < references_5.length; _i++) { + var reference = references_5[_i]; cancellationToken.throwIfCancellationRequested(); calculateUsageOfNode(reference, usage); } @@ -140524,33 +142688,44 @@ var ts; return ts.factory.updateMethodDeclaration(signatureDeclaration, /*decorators*/ undefined, modifiers, signatureDeclaration.asteriskToken, name, optional ? ts.factory.createToken(57 /* QuestionToken */) : undefined, typeParameters, parameters, type, body); } - function createMethodFromCallExpression(context, importAdder, call, methodName, modifierFlags, contextNode, inJs) { - var body = !ts.isInterfaceDeclaration(contextNode); - var typeArguments = call.typeArguments, args = call.arguments, parent = call.parent; + function createSignatureDeclarationFromCallExpression(kind, context, importAdder, call, name, modifierFlags, contextNode) { + var quotePreference = ts.getQuotePreference(context.sourceFile, context.preferences); var scriptTarget = ts.getEmitScriptTarget(context.program.getCompilerOptions()); - var checker = context.program.getTypeChecker(); var tracker = getNoopSymbolTrackerWithResolver(context); - var types = ts.map(args, function (arg) { - return typeToAutoImportableTypeNode(checker, importAdder, checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(arg)), contextNode, scriptTarget, /*flags*/ undefined, tracker); - }); + var checker = context.program.getTypeChecker(); + var isJs = ts.isInJSFile(contextNode); + var typeArguments = call.typeArguments, args = call.arguments, parent = call.parent; + var contextualType = isJs ? undefined : checker.getContextualType(call); var names = ts.map(args, function (arg) { return ts.isIdentifier(arg) ? arg.text : ts.isPropertyAccessExpression(arg) && ts.isIdentifier(arg.name) ? arg.name.text : undefined; }); - var contextualType = checker.getContextualType(call); - var returnType = (inJs || !contextualType) ? undefined : checker.typeToTypeNode(contextualType, contextNode, /*flags*/ undefined, tracker); - var quotePreference = ts.getQuotePreference(context.sourceFile, context.preferences); - return ts.factory.createMethodDeclaration( - /*decorators*/ undefined, - /*modifiers*/ modifierFlags ? ts.factory.createNodeArray(ts.factory.createModifiersFromModifierFlags(modifierFlags)) : undefined, - /*asteriskToken*/ ts.isYieldExpression(parent) ? ts.factory.createToken(41 /* AsteriskToken */) : undefined, methodName, - /*questionToken*/ undefined, - /*typeParameters*/ inJs ? undefined : ts.map(typeArguments, function (_, i) { - return ts.factory.createTypeParameterDeclaration(84 /* T */ + typeArguments.length - 1 <= 90 /* Z */ ? String.fromCharCode(84 /* T */ + i) : "T" + i); - }), - /*parameters*/ createDummyParameters(args.length, names, types, /*minArgumentCount*/ undefined, inJs), - /*type*/ returnType, body ? createStubbedMethodBody(quotePreference) : undefined); + var types = isJs ? [] : ts.map(args, function (arg) { + return typeToAutoImportableTypeNode(checker, importAdder, checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(arg)), contextNode, scriptTarget, /*flags*/ undefined, tracker); + }); + var modifiers = modifierFlags + ? ts.factory.createNodeArray(ts.factory.createModifiersFromModifierFlags(modifierFlags)) + : undefined; + var asteriskToken = ts.isYieldExpression(parent) + ? ts.factory.createToken(41 /* AsteriskToken */) + : undefined; + var typeParameters = isJs || typeArguments === undefined + ? undefined + : ts.map(typeArguments, function (_, i) { + return ts.factory.createTypeParameterDeclaration(84 /* T */ + typeArguments.length - 1 <= 90 /* Z */ ? String.fromCharCode(84 /* T */ + i) : "T" + i); + }); + var parameters = createDummyParameters(args.length, names, types, /*minArgumentCount*/ undefined, isJs); + var type = isJs || contextualType === undefined + ? undefined + : checker.typeToTypeNode(contextualType, contextNode, /*flags*/ undefined, tracker); + if (kind === 165 /* MethodDeclaration */) { + return ts.factory.createMethodDeclaration( + /*decorators*/ undefined, modifiers, asteriskToken, name, + /*questionToken*/ undefined, typeParameters, parameters, type, ts.isInterfaceDeclaration(contextNode) ? undefined : createStubbedMethodBody(quotePreference)); + } + return ts.factory.createFunctionDeclaration( + /*decorators*/ undefined, modifiers, asteriskToken, name, typeParameters, parameters, type, createStubbedBody(ts.Diagnostics.Function_not_implemented.message, quotePreference)); } - codefix.createMethodFromCallExpression = createMethodFromCallExpression; + codefix.createSignatureDeclarationFromCallExpression = createSignatureDeclarationFromCallExpression; function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, scriptTarget, flags, tracker) { var typeNode = checker.typeToTypeNode(type, contextNode, flags, tracker); if (typeNode && ts.isImportTypeNode(typeNode)) { @@ -140618,12 +142793,16 @@ var ts; /*asteriskToken*/ undefined, name, optional ? ts.factory.createToken(57 /* QuestionToken */) : undefined, typeParameters, parameters, returnType, createStubbedMethodBody(quotePreference)); } function createStubbedMethodBody(quotePreference) { + return createStubbedBody(ts.Diagnostics.Method_not_implemented.message, quotePreference); + } + function createStubbedBody(text, quotePreference) { return ts.factory.createBlock([ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier("Error"), /*typeArguments*/ undefined, // TODO Handle auto quote preference. - [ts.factory.createStringLiteral("Method not implemented.", /*isSingleQuote*/ quotePreference === 0 /* Single */)]))], + [ts.factory.createStringLiteral(text, /*isSingleQuote*/ quotePreference === 0 /* Single */)]))], /*multiline*/ true); } + codefix.createStubbedBody = createStubbedBody; function createVisibilityModifier(flags) { if (flags & 4 /* Public */) { return ts.factory.createToken(122 /* PublicKeyword */); @@ -140720,10 +142899,10 @@ var ts; (function (codefix) { function generateAccessorFromProperty(file, program, start, end, context, _actionName) { var fieldInfo = getAccessorConvertiblePropertyAtPosition(file, program, start, end); - if (!fieldInfo || !fieldInfo.info) + if (!fieldInfo || ts.refactor.isRefactorErrorInfo(fieldInfo)) return undefined; var changeTracker = ts.textChanges.ChangeTracker.fromContext(context); - var _a = fieldInfo.info, isStatic = _a.isStatic, isReadonly = _a.isReadonly, fieldName = _a.fieldName, accessorName = _a.accessorName, originalName = _a.originalName, type = _a.type, container = _a.container, declaration = _a.declaration; + var isStatic = fieldInfo.isStatic, isReadonly = fieldInfo.isReadonly, fieldName = fieldInfo.fieldName, accessorName = fieldInfo.accessorName, originalName = fieldInfo.originalName, type = fieldInfo.type, container = fieldInfo.container, declaration = fieldInfo.declaration; ts.suppressLeadingAndTrailingTrivia(fieldName); ts.suppressLeadingAndTrailingTrivia(accessorName); ts.suppressLeadingAndTrailingTrivia(declaration); @@ -140818,17 +142997,15 @@ var ts; var fieldName = createPropertyName(startWithUnderscore ? name : ts.getUniqueName("_" + name, file), declaration.name); var accessorName = createPropertyName(startWithUnderscore ? ts.getUniqueName(name.substring(1), file) : name, declaration.name); return { - info: { - isStatic: ts.hasStaticModifier(declaration), - isReadonly: ts.hasEffectiveReadonlyModifier(declaration), - type: getDeclarationType(declaration, program), - container: declaration.kind === 160 /* Parameter */ ? declaration.parent.parent : declaration.parent, - originalName: declaration.name.text, - declaration: declaration, - fieldName: fieldName, - accessorName: accessorName, - renameAccessor: startWithUnderscore - } + isStatic: ts.hasStaticModifier(declaration), + isReadonly: ts.hasEffectiveReadonlyModifier(declaration), + type: getDeclarationType(declaration, program), + container: declaration.kind === 160 /* Parameter */ ? declaration.parent.parent : declaration.parent, + originalName: declaration.name.text, + declaration: declaration, + fieldName: fieldName, + accessorName: accessorName, + renameAccessor: startWithUnderscore }; } codefix.getAccessorConvertiblePropertyAtPosition = getAccessorConvertiblePropertyAtPosition; @@ -140900,7 +143077,7 @@ var ts; var type = typeChecker.getTypeFromTypeNode(typeNode); if (!typeChecker.isTypeAssignableTo(typeChecker.getUndefinedType(), type)) { var types = ts.isUnionTypeNode(typeNode) ? typeNode.types : [typeNode]; - return ts.factory.createUnionTypeNode(__spreadArrays(types, [ts.factory.createKeywordTypeNode(150 /* UndefinedKeyword */)])); + return ts.factory.createUnionTypeNode(__spreadArray(__spreadArray([], types), [ts.factory.createKeywordTypeNode(150 /* UndefinedKeyword */)])); } } return typeNode; @@ -140941,7 +143118,8 @@ var ts; // import Bluebird = require("bluebird"); variations.push(createAction(context, sourceFile, node, ts.factory.createImportEqualsDeclaration( /*decorators*/ undefined, - /*modifiers*/ undefined, namespace.name, ts.factory.createExternalModuleReference(node.moduleSpecifier)))); + /*modifiers*/ undefined, + /*isTypeOnly*/ false, namespace.name, ts.factory.createExternalModuleReference(node.moduleSpecifier)))); } return variations; } @@ -141157,7 +143335,7 @@ var ts; function doChange(changes, sourceFile, info) { var allowSyntheticDefaults = info.allowSyntheticDefaults, defaultImportName = info.defaultImportName, namedImports = info.namedImports, statement = info.statement, required = info.required; changes.replaceNode(sourceFile, statement, defaultImportName && !allowSyntheticDefaults - ? ts.factory.createImportEqualsDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, defaultImportName, ts.factory.createExternalModuleReference(required)) + ? ts.factory.createImportEqualsDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, /*isTypeOnly*/ false, defaultImportName, ts.factory.createExternalModuleReference(required)) : ts.factory.createImportDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, ts.factory.createImportClause(/*isTypeOnly*/ false, defaultImportName, namedImports), required)); } function getInfo(sourceFile, program, pos) { @@ -141426,9 +143604,9 @@ var ts; var mappedTypeParameter = ts.factory.createTypeParameterDeclaration(ts.cast(parameter.name, ts.isIdentifier), parameter.type); var mappedIntersectionType = ts.factory.createMappedTypeNode(ts.hasEffectiveReadonlyModifier(indexSignature) ? ts.factory.createModifier(142 /* ReadonlyKeyword */) : undefined, mappedTypeParameter, /*nameType*/ undefined, indexSignature.questionToken, indexSignature.type); - var intersectionType = ts.factory.createIntersectionTypeNode(__spreadArrays(ts.getAllSuperTypeNodes(container), [ + var intersectionType = ts.factory.createIntersectionTypeNode(__spreadArray(__spreadArray(__spreadArray([], ts.getAllSuperTypeNodes(container)), [ mappedIntersectionType - ], (otherMembers.length ? [ts.factory.createTypeLiteralNode(otherMembers)] : ts.emptyArray))); + ]), (otherMembers.length ? [ts.factory.createTypeLiteralNode(otherMembers)] : ts.emptyArray))); changes.replaceNode(sourceFile, container, createTypeAliasFromInterface(container, intersectionType)); } })(codefix = ts.codefix || (ts.codefix = {})); @@ -141702,32 +143880,48 @@ var ts; var refactor; (function (refactor) { var refactorName = "Convert export"; - var actionNameDefaultToNamed = "Convert default export to named export"; - var actionNameNamedToDefault = "Convert named export to default export"; + var defaultToNamedAction = { + name: "Convert default export to named export", + description: ts.Diagnostics.Convert_default_export_to_named_export.message, + kind: "refactor.rewrite.export.named" + }; + var namedToDefaultAction = { + name: "Convert named export to default export", + description: ts.Diagnostics.Convert_named_export_to_default_export.message, + kind: "refactor.rewrite.export.default" + }; refactor.registerRefactor(refactorName, { + kinds: [ + defaultToNamedAction.kind, + namedToDefaultAction.kind + ], getAvailableActions: function (context) { var info = getInfo(context, context.triggerReason === "invoked"); if (!info) return ts.emptyArray; - if (info.error === undefined) { - var description = info.info.wasDefault ? ts.Diagnostics.Convert_default_export_to_named_export.message : ts.Diagnostics.Convert_named_export_to_default_export.message; - var actionName = info.info.wasDefault ? actionNameDefaultToNamed : actionNameNamedToDefault; - return [{ name: refactorName, description: description, actions: [{ name: actionName, description: description }] }]; + if (!refactor.isRefactorErrorInfo(info)) { + var action = info.wasDefault ? defaultToNamedAction : namedToDefaultAction; + return [{ name: refactorName, description: action.description, actions: [action] }]; } if (context.preferences.provideRefactorNotApplicableReason) { return [ - { name: refactorName, description: ts.Diagnostics.Convert_default_export_to_named_export.message, actions: [{ name: actionNameDefaultToNamed, description: ts.Diagnostics.Convert_default_export_to_named_export.message, notApplicableReason: info.error }] }, - { name: refactorName, description: ts.Diagnostics.Convert_named_export_to_default_export.message, actions: [{ name: actionNameNamedToDefault, description: ts.Diagnostics.Convert_named_export_to_default_export.message, notApplicableReason: info.error }] }, + { name: refactorName, description: ts.Diagnostics.Convert_default_export_to_named_export.message, actions: [ + __assign(__assign({}, defaultToNamedAction), { notApplicableReason: info.error }), + __assign(__assign({}, namedToDefaultAction), { notApplicableReason: info.error }), + ] } ]; } return ts.emptyArray; }, getEditsForAction: function (context, actionName) { - ts.Debug.assert(actionName === actionNameDefaultToNamed || actionName === actionNameNamedToDefault, "Unexpected action name"); - var edits = ts.textChanges.ChangeTracker.with(context, function (t) { var _a; return doChange(context.file, context.program, ts.Debug.checkDefined((_a = getInfo(context)) === null || _a === void 0 ? void 0 : _a.info, "context must have info"), t, context.cancellationToken); }); + ts.Debug.assert(actionName === defaultToNamedAction.name || actionName === namedToDefaultAction.name, "Unexpected action name"); + var info = getInfo(context); + ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info"); + var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, context.program, info, t, context.cancellationToken); }); return { edits: edits, renameFilename: undefined, renameLocation: undefined }; }, }); + ; function getInfo(context, considerPartialSpans) { if (considerPartialSpans === void 0) { considerPartialSpans = true; } var file = context.file; @@ -141752,7 +143946,7 @@ var ts; case 254 /* TypeAliasDeclaration */: case 256 /* ModuleDeclaration */: { var node = exportNode; - return node.name && ts.isIdentifier(node.name) ? { info: { exportNode: node, exportName: node.name, wasDefault: wasDefault, exportingModuleSymbol: exportingModuleSymbol } } : undefined; + return node.name && ts.isIdentifier(node.name) ? { exportNode: node, exportName: node.name, wasDefault: wasDefault, exportingModuleSymbol: exportingModuleSymbol } : undefined; } case 232 /* VariableStatement */: { var vs = exportNode; @@ -141764,7 +143958,7 @@ var ts; if (!decl.initializer) return undefined; ts.Debug.assert(!wasDefault, "Can't have a default flag here"); - return ts.isIdentifier(decl.name) ? { info: { exportNode: vs, exportName: decl.name, wasDefault: wasDefault, exportingModuleSymbol: exportingModuleSymbol } } : undefined; + return ts.isIdentifier(decl.name) ? { exportNode: vs, exportName: decl.name, wasDefault: wasDefault, exportingModuleSymbol: exportingModuleSymbol } : undefined; } default: return undefined; @@ -141909,29 +144103,43 @@ var ts; var refactor; (function (refactor) { var refactorName = "Convert import"; - var actionNameNamespaceToNamed = "Convert namespace import to named imports"; - var actionNameNamedToNamespace = "Convert named imports to namespace import"; + var namespaceToNamedAction = { + name: "Convert namespace import to named imports", + description: ts.Diagnostics.Convert_namespace_import_to_named_imports.message, + kind: "refactor.rewrite.import.named", + }; + var namedToNamespaceAction = { + name: "Convert named imports to namespace import", + description: ts.Diagnostics.Convert_named_imports_to_namespace_import.message, + kind: "refactor.rewrite.import.namespace", + }; refactor.registerRefactor(refactorName, { + kinds: [ + namespaceToNamedAction.kind, + namedToNamespaceAction.kind + ], getAvailableActions: function (context) { - var i = getImportToConvert(context, context.triggerReason === "invoked"); - if (!i) + var info = getImportToConvert(context, context.triggerReason === "invoked"); + if (!info) return ts.emptyArray; - if (i.error === undefined) { - var description = i.info.kind === 263 /* NamespaceImport */ ? ts.Diagnostics.Convert_namespace_import_to_named_imports.message : ts.Diagnostics.Convert_named_imports_to_namespace_import.message; - var actionName = i.info.kind === 263 /* NamespaceImport */ ? actionNameNamespaceToNamed : actionNameNamedToNamespace; - return [{ name: refactorName, description: description, actions: [{ name: actionName, description: description }] }]; + if (!refactor.isRefactorErrorInfo(info)) { + var namespaceImport = info.kind === 263 /* NamespaceImport */; + var action = namespaceImport ? namespaceToNamedAction : namedToNamespaceAction; + return [{ name: refactorName, description: action.description, actions: [action] }]; } if (context.preferences.provideRefactorNotApplicableReason) { return [ - { name: refactorName, description: ts.Diagnostics.Convert_namespace_import_to_named_imports.message, actions: [{ name: actionNameNamespaceToNamed, description: ts.Diagnostics.Convert_namespace_import_to_named_imports.message, notApplicableReason: i.error }] }, - { name: refactorName, description: ts.Diagnostics.Convert_named_imports_to_namespace_import.message, actions: [{ name: actionNameNamedToNamespace, description: ts.Diagnostics.Convert_named_imports_to_namespace_import.message, notApplicableReason: i.error }] } + { name: refactorName, description: namespaceToNamedAction.description, actions: [__assign(__assign({}, namespaceToNamedAction), { notApplicableReason: info.error })] }, + { name: refactorName, description: namedToNamespaceAction.description, actions: [__assign(__assign({}, namedToNamespaceAction), { notApplicableReason: info.error })] } ]; } return ts.emptyArray; }, getEditsForAction: function (context, actionName) { - ts.Debug.assert(actionName === actionNameNamespaceToNamed || actionName === actionNameNamedToNamespace, "Unexpected action name"); - var edits = ts.textChanges.ChangeTracker.with(context, function (t) { var _a; return doChange(context.file, context.program, t, ts.Debug.checkDefined((_a = getImportToConvert(context)) === null || _a === void 0 ? void 0 : _a.info, "Context must provide an import to convert")); }); + ts.Debug.assert(actionName === namespaceToNamedAction.name || actionName === namedToNamespaceAction.name, "Unexpected action name"); + var info = getImportToConvert(context); + ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info"); + var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, context.program, t, info); }); return { edits: edits, renameFilename: undefined, renameLocation: undefined }; } }); @@ -141953,7 +144161,7 @@ var ts; if (!importClause.namedBindings) { return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_namespace_import_or_named_imports) }; } - return { info: importClause.namedBindings }; + return importClause.namedBindings; } function doChange(sourceFile, program, changes, toConvert) { var checker = program.getTypeChecker(); @@ -141969,29 +144177,28 @@ var ts; var nodesToReplace = []; var conflictingNames = new ts.Map(); ts.FindAllReferences.Core.eachSymbolReferenceInFile(toConvert.name, checker, sourceFile, function (id) { - if (!ts.isPropertyAccessExpression(id.parent)) { + if (!ts.isPropertyAccessOrQualifiedName(id.parent)) { usedAsNamespaceOrDefault = true; } else { - var parent = ts.cast(id.parent, ts.isPropertyAccessExpression); - var exportName = parent.name.text; + var exportName = getRightOfPropertyAccessOrQualifiedName(id.parent).text; if (checker.resolveName(exportName, id, 67108863 /* All */, /*excludeGlobals*/ true)) { conflictingNames.set(exportName, true); } - ts.Debug.assert(parent.expression === id, "Parent expression should match id"); - nodesToReplace.push(parent); + ts.Debug.assert(getLeftOfPropertyAccessOrQualifiedName(id.parent) === id, "Parent expression should match id"); + nodesToReplace.push(id.parent); } }); // We may need to change `mod.x` to `_x` to avoid a name conflict. var exportNameToImportName = new ts.Map(); for (var _i = 0, nodesToReplace_1 = nodesToReplace; _i < nodesToReplace_1.length; _i++) { - var propertyAccess = nodesToReplace_1[_i]; - var exportName = propertyAccess.name.text; + var propertyAccessOrQualifiedName = nodesToReplace_1[_i]; + var exportName = getRightOfPropertyAccessOrQualifiedName(propertyAccessOrQualifiedName).text; var importName = exportNameToImportName.get(exportName); if (importName === undefined) { exportNameToImportName.set(exportName, importName = conflictingNames.has(exportName) ? ts.getUniqueName(exportName, sourceFile) : exportName); } - changes.replaceNode(sourceFile, propertyAccess, ts.factory.createIdentifier(importName)); + changes.replaceNode(sourceFile, propertyAccessOrQualifiedName, ts.factory.createIdentifier(importName)); } var importSpecifiers = []; exportNameToImportName.forEach(function (name, propertyName) { @@ -142006,6 +144213,12 @@ var ts; changes.replaceNode(sourceFile, importDecl, updateImport(importDecl, usedAsNamespaceOrDefault ? ts.factory.createIdentifier(toConvert.name.text) : undefined, importSpecifiers)); } } + function getRightOfPropertyAccessOrQualifiedName(propertyAccessOrQualifiedName) { + return ts.isPropertyAccessExpression(propertyAccessOrQualifiedName) ? propertyAccessOrQualifiedName.name : propertyAccessOrQualifiedName.right; + } + function getLeftOfPropertyAccessOrQualifiedName(propertyAccessOrQualifiedName) { + return ts.isPropertyAccessExpression(propertyAccessOrQualifiedName) ? propertyAccessOrQualifiedName.expression : propertyAccessOrQualifiedName.left; + } function doChangeNamedToNamespace(sourceFile, checker, changes, toConvert) { var importDecl = toConvert.parent.parent; var moduleSpecifier = importDecl.moduleSpecifier; @@ -142057,40 +144270,41 @@ var ts; (function (convertToOptionalChainExpression) { var refactorName = "Convert to optional chain expression"; var convertToOptionalChainExpressionMessage = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_optional_chain_expression); - refactor.registerRefactor(refactorName, { getAvailableActions: getAvailableActions, getEditsForAction: getEditsForAction }); + var toOptionalChainAction = { + name: refactorName, + description: convertToOptionalChainExpressionMessage, + kind: "refactor.rewrite.expression.optionalChain", + }; + refactor.registerRefactor(refactorName, { + kinds: [toOptionalChainAction.kind], + getAvailableActions: getAvailableActions, + getEditsForAction: getEditsForAction + }); function getAvailableActions(context) { var info = getInfo(context, context.triggerReason === "invoked"); if (!info) return ts.emptyArray; - if (!info.error) { + if (!refactor.isRefactorErrorInfo(info)) { return [{ name: refactorName, description: convertToOptionalChainExpressionMessage, - actions: [{ - name: refactorName, - description: convertToOptionalChainExpressionMessage - }] + actions: [toOptionalChainAction], }]; } if (context.preferences.provideRefactorNotApplicableReason) { return [{ name: refactorName, description: convertToOptionalChainExpressionMessage, - actions: [{ - name: refactorName, - description: convertToOptionalChainExpressionMessage, - notApplicableReason: info.error - }] + actions: [__assign(__assign({}, toOptionalChainAction), { notApplicableReason: info.error })], }]; } return ts.emptyArray; } function getEditsForAction(context, actionName) { var info = getInfo(context); - if (!info || !info.info) - return undefined; + ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info"); var edits = ts.textChanges.ChangeTracker.with(context, function (t) { - return doChange(context.file, context.program.getTypeChecker(), t, ts.Debug.checkDefined(info.info, "context must have info"), actionName); + return doChange(context.file, context.program.getTypeChecker(), t, info, actionName); }); return { edits: edits, renameFilename: undefined, renameLocation: undefined }; } @@ -142130,11 +144344,11 @@ var ts; } if ((ts.isPropertyAccessExpression(condition) || ts.isIdentifier(condition)) && getMatchingStart(condition, finalExpression.expression)) { - return { info: { finalExpression: finalExpression, occurrences: [condition], expression: expression } }; + return { finalExpression: finalExpression, occurrences: [condition], expression: expression }; } else if (ts.isBinaryExpression(condition)) { var occurrences = getOccurrencesInExpression(finalExpression.expression, condition); - return occurrences ? { info: { finalExpression: finalExpression, occurrences: occurrences, expression: expression } } : + return occurrences ? { finalExpression: finalExpression, occurrences: occurrences, expression: expression } : { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_matching_access_expressions) }; } } @@ -142147,7 +144361,7 @@ var ts; if (!finalExpression) return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_convertible_access_expression) }; var occurrences = getOccurrencesInExpression(finalExpression.expression, expression.left); - return occurrences ? { info: { finalExpression: finalExpression, occurrences: occurrences, expression: expression } } : + return occurrences ? { finalExpression: finalExpression, occurrences: occurrences, expression: expression } : { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_matching_access_expressions) }; } /** @@ -142322,7 +144536,16 @@ var ts; (function (addOrRemoveBracesToArrowFunction) { var refactorName = "Convert overload list to single signature"; var refactorDescription = ts.Diagnostics.Convert_overload_list_to_single_signature.message; - refactor.registerRefactor(refactorName, { getEditsForAction: getEditsForAction, getAvailableActions: getAvailableActions }); + var functionOverloadAction = { + name: refactorName, + description: refactorDescription, + kind: "refactor.rewrite.function.overloadList", + }; + refactor.registerRefactor(refactorName, { + kinds: [functionOverloadAction.kind], + getEditsForAction: getEditsForAction, + getAvailableActions: getAvailableActions + }); function getAvailableActions(context) { var file = context.file, startPosition = context.startPosition, program = context.program; var info = getConvertableOverloadListAtPosition(file, startPosition, program); @@ -142331,10 +144554,7 @@ var ts; return [{ name: refactorName, description: refactorDescription, - actions: [{ - name: refactorName, - description: refactorDescription - }] + actions: [functionOverloadAction] }]; } function getEditsForAction(context) { @@ -142478,36 +144698,52 @@ var ts; var extractSymbol; (function (extractSymbol) { var refactorName = "Extract Symbol"; - refactor.registerRefactor(refactorName, { getAvailableActions: getAvailableActions, getEditsForAction: getEditsForAction }); + var extractConstantAction = { + name: "Extract Constant", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_constant), + kind: "refactor.extract.constant", + }; + var extractFunctionAction = { + name: "Extract Function", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_function), + kind: "refactor.extract.function", + }; + refactor.registerRefactor(refactorName, { + kinds: [ + extractConstantAction.kind, + extractFunctionAction.kind + ], + getAvailableActions: getAvailableActions, + getEditsForAction: getEditsForAction + }); /** * Compute the associated code actions * Exported for tests. */ function getAvailableActions(context) { + var requestedRefactor = context.kind; var rangeToExtract = getRangeToExtract(context.file, ts.getRefactorContextSpan(context), context.triggerReason === "invoked"); var targetRange = rangeToExtract.targetRange; if (targetRange === undefined) { if (!rangeToExtract.errors || rangeToExtract.errors.length === 0 || !context.preferences.provideRefactorNotApplicableReason) { return ts.emptyArray; } - return [{ + var errors = []; + if (refactor.refactorKindBeginsWith(extractFunctionAction.kind, requestedRefactor)) { + errors.push({ name: refactorName, - description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_function), - actions: [{ - description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_function), - name: "function_extract_error", - notApplicableReason: getStringError(rangeToExtract.errors) - }] - }, - { + description: extractFunctionAction.description, + actions: [__assign(__assign({}, extractFunctionAction), { notApplicableReason: getStringError(rangeToExtract.errors) })] + }); + } + if (refactor.refactorKindBeginsWith(extractConstantAction.kind, requestedRefactor)) { + errors.push({ name: refactorName, - description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_constant), - actions: [{ - description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_constant), - name: "constant_extract_error", - notApplicableReason: getStringError(rangeToExtract.errors) - }] - }]; + description: extractConstantAction.description, + actions: [__assign(__assign({}, extractConstantAction), { notApplicableReason: getStringError(rangeToExtract.errors) })] + }); + } + return errors; } var extractions = getPossibleExtractions(targetRange, context); if (extractions === undefined) { @@ -142524,45 +144760,53 @@ var ts; for (var _i = 0, extractions_1 = extractions; _i < extractions_1.length; _i++) { var _a = extractions_1[_i], functionExtraction = _a.functionExtraction, constantExtraction = _a.constantExtraction; var description = functionExtraction.description; - if (functionExtraction.errors.length === 0) { - // Don't issue refactorings with duplicated names. - // Scopes come back in "innermost first" order, so extractions will - // preferentially go into nearer scopes - if (!usedFunctionNames.has(description)) { - usedFunctionNames.set(description, true); - functionActions.push({ + if (refactor.refactorKindBeginsWith(extractFunctionAction.kind, requestedRefactor)) { + if (functionExtraction.errors.length === 0) { + // Don't issue refactorings with duplicated names. + // Scopes come back in "innermost first" order, so extractions will + // preferentially go into nearer scopes + if (!usedFunctionNames.has(description)) { + usedFunctionNames.set(description, true); + functionActions.push({ + description: description, + name: "function_scope_" + i, + kind: extractFunctionAction.kind + }); + } + } + else if (!innermostErrorFunctionAction) { + innermostErrorFunctionAction = { description: description, - name: "function_scope_" + i - }); + name: "function_scope_" + i, + notApplicableReason: getStringError(functionExtraction.errors), + kind: extractFunctionAction.kind + }; } } - else if (!innermostErrorFunctionAction) { - innermostErrorFunctionAction = { - description: description, - name: "function_scope_" + i, - notApplicableReason: getStringError(functionExtraction.errors) - }; - } // Skip these since we don't have a way to report errors yet - if (constantExtraction.errors.length === 0) { - // Don't issue refactorings with duplicated names. - // Scopes come back in "innermost first" order, so extractions will - // preferentially go into nearer scopes - var description_1 = constantExtraction.description; - if (!usedConstantNames.has(description_1)) { - usedConstantNames.set(description_1, true); - constantActions.push({ - description: description_1, - name: "constant_scope_" + i - }); + if (refactor.refactorKindBeginsWith(extractConstantAction.kind, requestedRefactor)) { + if (constantExtraction.errors.length === 0) { + // Don't issue refactorings with duplicated names. + // Scopes come back in "innermost first" order, so extractions will + // preferentially go into nearer scopes + var description_1 = constantExtraction.description; + if (!usedConstantNames.has(description_1)) { + usedConstantNames.set(description_1, true); + constantActions.push({ + description: description_1, + name: "constant_scope_" + i, + kind: extractConstantAction.kind + }); + } + } + else if (!innermostErrorConstantAction) { + innermostErrorConstantAction = { + description: description, + name: "constant_scope_" + i, + notApplicableReason: getStringError(constantExtraction.errors), + kind: extractConstantAction.kind + }; } - } - else if (!innermostErrorConstantAction) { - innermostErrorConstantAction = { - description: description, - name: "constant_scope_" + i, - notApplicableReason: getStringError(constantExtraction.errors) - }; } // *do* increment i anyway because we'll look for the i-th scope // later when actually doing the refactoring if the user requests it @@ -142573,7 +144817,7 @@ var ts; infos.push({ name: refactorName, description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_function), - actions: functionActions + actions: functionActions, }); } else if (context.preferences.provideRefactorNotApplicableReason && innermostErrorFunctionAction) { @@ -144142,25 +146386,37 @@ var ts; var refactor; (function (refactor) { var refactorName = "Extract type"; - var extractToTypeAlias = "Extract to type alias"; - var extractToInterface = "Extract to interface"; - var extractToTypeDef = "Extract to typedef"; + var extractToTypeAliasAction = { + name: "Extract to type alias", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_type_alias), + kind: "refactor.extract.type", + }; + var extractToInterfaceAction = { + name: "Extract to interface", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_interface), + kind: "refactor.extract.interface", + }; + var extractToTypeDefAction = { + name: "Extract to typedef", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_typedef), + kind: "refactor.extract.typedef" + }; refactor.registerRefactor(refactorName, { + kinds: [ + extractToTypeAliasAction.kind, + extractToInterfaceAction.kind, + extractToTypeDefAction.kind + ], getAvailableActions: function (context) { var info = getRangeToExtract(context, context.triggerReason === "invoked"); if (!info) return ts.emptyArray; - if (info.error === undefined) { + if (!refactor.isRefactorErrorInfo(info)) { return [{ name: refactorName, description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_type), - actions: info.info.isJS ? [{ - name: extractToTypeDef, description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_typedef) - }] : ts.append([{ - name: extractToTypeAlias, description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_type_alias) - }], info.info.typeElements && { - name: extractToInterface, description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_interface) - }) + actions: info.isJS ? + [extractToTypeDefAction] : ts.append([extractToTypeAliasAction], info.typeElements && extractToInterfaceAction) }]; } if (context.preferences.provideRefactorNotApplicableReason) { @@ -144168,28 +146424,28 @@ var ts; name: refactorName, description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_type), actions: [ - { name: extractToTypeDef, description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_typedef), notApplicableReason: info.error }, - { name: extractToTypeAlias, description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_type_alias), notApplicableReason: info.error }, - { name: extractToInterface, description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_interface), notApplicableReason: info.error }, + __assign(__assign({}, extractToTypeDefAction), { notApplicableReason: info.error }), + __assign(__assign({}, extractToTypeAliasAction), { notApplicableReason: info.error }), + __assign(__assign({}, extractToInterfaceAction), { notApplicableReason: info.error }), ] }]; } return ts.emptyArray; }, getEditsForAction: function (context, actionName) { - var _a; var file = context.file; - var info = ts.Debug.checkDefined((_a = getRangeToExtract(context)) === null || _a === void 0 ? void 0 : _a.info, "Expected to find a range to extract"); + var info = getRangeToExtract(context); + ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected to find a range to extract"); var name = ts.getUniqueName("NewType", file); var edits = ts.textChanges.ChangeTracker.with(context, function (changes) { switch (actionName) { - case extractToTypeAlias: + case extractToTypeAliasAction.name: ts.Debug.assert(!info.isJS, "Invalid actionName/JS combo"); return doTypeAliasChange(changes, file, name, info); - case extractToTypeDef: + case extractToTypeDefAction.name: ts.Debug.assert(info.isJS, "Invalid actionName/JS combo"); return doTypedefChange(changes, file, name, info); - case extractToInterface: + case extractToInterfaceAction.name: ts.Debug.assert(!info.isJS && !!info.typeElements, "Invalid actionName/JS combo"); return doInterfaceChange(changes, file, name, info); default: @@ -144218,7 +146474,7 @@ var ts; if (!typeParameters) return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.No_type_could_be_extracted_from_this_type_node) }; var typeElements = flattenTypeLiteralNodeReference(checker, selection); - return { info: { isJS: isJS, selection: selection, firstStatement: firstStatement, typeParameters: typeParameters, typeElements: typeElements } }; + return { isJS: isJS, selection: selection, firstStatement: firstStatement, typeParameters: typeParameters, typeElements: typeElements }; } function flattenTypeLiteralNodeReference(checker, node) { if (!node) @@ -144336,20 +146592,25 @@ var ts; (function (generateGetAccessorAndSetAccessor) { var actionName = "Generate 'get' and 'set' accessors"; var actionDescription = ts.Diagnostics.Generate_get_and_set_accessors.message; + var generateGetSetAction = { + name: actionName, + description: actionDescription, + kind: "refactor.rewrite.property.generateAccessors", + }; refactor.registerRefactor(actionName, { + kinds: [generateGetSetAction.kind], getEditsForAction: function (context, actionName) { if (!context.endPosition) return undefined; var info = ts.codefix.getAccessorConvertiblePropertyAtPosition(context.file, context.program, context.startPosition, context.endPosition); - if (!info || !info.info) - return undefined; + ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info"); var edits = ts.codefix.generateAccessorFromProperty(context.file, context.program, context.startPosition, context.endPosition, context, actionName); if (!edits) return undefined; var renameFilename = context.file.fileName; - var nameNeedRename = info.info.renameAccessor ? info.info.accessorName : info.info.fieldName; + var nameNeedRename = info.renameAccessor ? info.accessorName : info.fieldName; var renameLocationOffset = ts.isIdentifier(nameNeedRename) ? 0 : -1; - var renameLocation = renameLocationOffset + ts.getRenameLocation(edits, renameFilename, nameNeedRename.text, /*preferLastLocation*/ ts.isParameter(info.info.declaration)); + var renameLocation = renameLocationOffset + ts.getRenameLocation(edits, renameFilename, nameNeedRename.text, /*preferLastLocation*/ ts.isParameter(info.declaration)); return { renameFilename: renameFilename, renameLocation: renameLocation, edits: edits }; }, getAvailableActions: function (context) { @@ -144358,27 +146619,18 @@ var ts; var info = ts.codefix.getAccessorConvertiblePropertyAtPosition(context.file, context.program, context.startPosition, context.endPosition, context.triggerReason === "invoked"); if (!info) return ts.emptyArray; - if (!info.error) { + if (!refactor.isRefactorErrorInfo(info)) { return [{ name: actionName, description: actionDescription, - actions: [ - { - name: actionName, - description: actionDescription - } - ] + actions: [generateGetSetAction], }]; } if (context.preferences.provideRefactorNotApplicableReason) { return [{ name: actionName, description: actionDescription, - actions: [{ - name: actionName, - description: actionDescription, - notApplicableReason: info.error - }] + actions: [__assign(__assign({}, generateGetSetAction), { notApplicableReason: info.error })], }]; } return ts.emptyArray; @@ -144389,16 +146641,53 @@ var ts; })(ts || (ts = {})); /* @internal */ var ts; +(function (ts) { + var refactor; + (function (refactor) { + ; + /** + * Checks if some refactor info has refactor error info. + */ + function isRefactorErrorInfo(info) { + return info.error !== undefined; + } + refactor.isRefactorErrorInfo = isRefactorErrorInfo; + /** + * Checks if string "known" begins with string "requested". + * Used to match requested kinds with a known kind. + */ + function refactorKindBeginsWith(known, requested) { + if (!requested) + return true; + return known.substr(0, requested.length) === requested; + } + refactor.refactorKindBeginsWith = refactorKindBeginsWith; + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; (function (ts) { var refactor; (function (refactor) { var refactorName = "Move to a new file"; + var description = ts.getLocaleSpecificMessage(ts.Diagnostics.Move_to_a_new_file); + var moveToNewFileAction = { + name: refactorName, + description: description, + kind: "refactor.move.newFile", + }; refactor.registerRefactor(refactorName, { + kinds: [moveToNewFileAction.kind], getAvailableActions: function (context) { - if (!context.preferences.allowTextChangesInNewFiles || getStatementsToMove(context) === undefined) - return ts.emptyArray; - var description = ts.getLocaleSpecificMessage(ts.Diagnostics.Move_to_a_new_file); - return [{ name: refactorName, description: description, actions: [{ name: refactorName, description: description }] }]; + var statements = getStatementsToMove(context); + if (context.preferences.allowTextChangesInNewFiles && statements) { + return [{ name: refactorName, description: description, actions: [moveToNewFileAction] }]; + } + if (context.preferences.provideRefactorNotApplicableReason) { + return [{ name: refactorName, description: description, actions: [__assign(__assign({}, moveToNewFileAction), { notApplicableReason: ts.getLocaleSpecificMessage(ts.Diagnostics.Selection_is_not_a_valid_statement_or_statements) })] + }]; + } + return ts.emptyArray; }, getEditsForAction: function (context, actionName) { ts.Debug.assert(actionName === refactorName, "Wrong refactor invoked"); @@ -144493,7 +146782,7 @@ var ts; var prologueDirectives = ts.takeWhile(oldFile.statements, ts.isPrologueDirective); if (!oldFile.externalModuleIndicator && !oldFile.commonJsModuleIndicator) { deleteMovedStatements(oldFile, toMove.ranges, changes); - return __spreadArrays(prologueDirectives, toMove.all); + return __spreadArray(__spreadArray([], prologueDirectives), toMove.all); } var useEs6ModuleSyntax = !!oldFile.externalModuleIndicator; var quotePreference = ts.getQuotePreference(oldFile, preferences); @@ -144507,11 +146796,11 @@ var ts; var imports = getNewFileImportsAndAddExportInOldFile(oldFile, usage.oldImportsNeededByNewFile, usage.newFileImportsFromOldFile, changes, checker, useEs6ModuleSyntax, quotePreference); var body = addExports(oldFile, toMove.all, usage.oldFileImportsFromNewFile, useEs6ModuleSyntax); if (imports.length && body.length) { - return __spreadArrays(prologueDirectives, imports, [ + return __spreadArray(__spreadArray(__spreadArray(__spreadArray([], prologueDirectives), imports), [ 4 /* NewLineTrivia */ - ], body); + ]), body); } - return __spreadArrays(prologueDirectives, imports, body); + return __spreadArray(__spreadArray(__spreadArray([], prologueDirectives), imports), body); } function deleteMovedStatements(sourceFile, moved, changes) { for (var _i = 0, moved_1 = moved; _i < moved_1.length; _i++) { @@ -144552,8 +146841,8 @@ var ts; updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleName, newModuleSpecifier, ns, importNode); }); }; - for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) { - var statement = _a[_i]; + for (var _b = 0, _c = sourceFile.statements; _b < _c.length; _b++) { + var statement = _c[_b]; _loop_18(statement); } }; @@ -144604,7 +146893,7 @@ var ts; return ts.factory.createImportDeclaration( /*decorators*/ undefined, /*modifiers*/ undefined, ts.factory.createImportClause(/*isTypeOnly*/ false, /*name*/ undefined, ts.factory.createNamespaceImport(newNamespaceId)), newModuleString); case 260 /* ImportEqualsDeclaration */: - return ts.factory.createImportEqualsDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, newNamespaceId, ts.factory.createExternalModuleReference(newModuleString)); + return ts.factory.createImportEqualsDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, /*isTypeOnly*/ false, newNamespaceId, ts.factory.createExternalModuleReference(newModuleString)); case 249 /* VariableDeclaration */: return ts.factory.createVariableDeclaration(newNamespaceId, /*exclamationToken*/ undefined, /*type*/ undefined, createRequireCall(newModuleString)); default: @@ -145072,7 +147361,7 @@ var ts; case 253 /* InterfaceDeclaration */: return ts.factory.updateInterfaceDeclaration(d, d.decorators, modifiers, d.name, d.typeParameters, d.heritageClauses, d.members); case 260 /* ImportEqualsDeclaration */: - return ts.factory.updateImportEqualsDeclaration(d, d.decorators, modifiers, d.name, d.moduleReference); + return ts.factory.updateImportEqualsDeclaration(d, d.decorators, modifiers, d.isTypeOnly, d.name, d.moduleReference); case 233 /* ExpressionStatement */: return ts.Debug.fail(); // Shouldn't try to add 'export' keyword to `exports.x = ...` default: @@ -145080,7 +147369,7 @@ var ts; } } function addCommonjsExport(decl) { - return __spreadArrays([decl], getNamesToExportInCommonJS(decl).map(createExportAssignment)); + return __spreadArray([decl], getNamesToExportInCommonJS(decl).map(createExportAssignment)); } function getNamesToExportInCommonJS(decl) { switch (decl.kind) { @@ -145116,29 +147405,32 @@ var ts; (function (addOrRemoveBracesToArrowFunction) { var refactorName = "Add or remove braces in an arrow function"; var refactorDescription = ts.Diagnostics.Add_or_remove_braces_in_an_arrow_function.message; - var addBracesActionName = "Add braces to arrow function"; - var removeBracesActionName = "Remove braces from arrow function"; - var addBracesActionDescription = ts.Diagnostics.Add_braces_to_arrow_function.message; - var removeBracesActionDescription = ts.Diagnostics.Remove_braces_from_arrow_function.message; - refactor.registerRefactor(refactorName, { getEditsForAction: getEditsForAction, getAvailableActions: getAvailableActions }); + var addBracesAction = { + name: "Add braces to arrow function", + description: ts.Diagnostics.Add_braces_to_arrow_function.message, + kind: "refactor.rewrite.arrow.braces.add", + }; + var removeBracesAction = { + name: "Remove braces from arrow function", + description: ts.Diagnostics.Remove_braces_from_arrow_function.message, + kind: "refactor.rewrite.arrow.braces.remove" + }; + refactor.registerRefactor(refactorName, { + kinds: [removeBracesAction.kind], + getEditsForAction: getEditsForAction, + getAvailableActions: getAvailableActions + }); function getAvailableActions(context) { var file = context.file, startPosition = context.startPosition, triggerReason = context.triggerReason; var info = getConvertibleArrowFunctionAtPosition(file, startPosition, triggerReason === "invoked"); if (!info) return ts.emptyArray; - if (info.error === undefined) { + if (!refactor.isRefactorErrorInfo(info)) { return [{ name: refactorName, description: refactorDescription, actions: [ - info.info.addBraces ? - { - name: addBracesActionName, - description: addBracesActionDescription - } : { - name: removeBracesActionName, - description: removeBracesActionDescription - } + info.addBraces ? addBracesAction : removeBracesAction ] }]; } @@ -145146,15 +147438,10 @@ var ts; return [{ name: refactorName, description: refactorDescription, - actions: [{ - name: addBracesActionName, - description: addBracesActionDescription, - notApplicableReason: info.error - }, { - name: removeBracesActionName, - description: removeBracesActionDescription, - notApplicableReason: info.error - }] + actions: [ + __assign(__assign({}, addBracesAction), { notApplicableReason: info.error }), + __assign(__assign({}, removeBracesAction), { notApplicableReason: info.error }), + ] }]; } return ts.emptyArray; @@ -145162,17 +147449,16 @@ var ts; function getEditsForAction(context, actionName) { var file = context.file, startPosition = context.startPosition; var info = getConvertibleArrowFunctionAtPosition(file, startPosition); - if (!info || !info.info) - return undefined; - var _a = info.info, expression = _a.expression, returnStatement = _a.returnStatement, func = _a.func; + ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info"); + var expression = info.expression, returnStatement = info.returnStatement, func = info.func; var body; - if (actionName === addBracesActionName) { + if (actionName === addBracesAction.name) { var returnStatement_1 = ts.factory.createReturnStatement(expression); body = ts.factory.createBlock([returnStatement_1], /* multiLine */ true); ts.suppressLeadingAndTrailingTrivia(body); ts.copyLeadingComments(expression, returnStatement_1, file, 3 /* MultiLineCommentTrivia */, /* hasTrailingNewLine */ true); } - else if (actionName === removeBracesActionName && returnStatement) { + else if (actionName === removeBracesAction.name && returnStatement) { var actualExpression = expression || ts.factory.createVoidZero(); body = ts.needsParentheses(actualExpression) ? ts.factory.createParenthesizedExpression(actualExpression) : actualExpression; ts.suppressLeadingAndTrailingTrivia(body); @@ -145188,7 +147474,7 @@ var ts; }); return { renameFilename: undefined, renameLocation: undefined, edits: edits }; } - function getConvertibleArrowFunctionAtPosition(file, startPosition, considerFunctionBodies) { + function getConvertibleArrowFunctionAtPosition(file, startPosition, considerFunctionBodies, kind) { if (considerFunctionBodies === void 0) { considerFunctionBodies = true; } var node = ts.getTokenAtPosition(file, startPosition); var func = ts.getContainingFunction(node); @@ -145205,26 +147491,13 @@ var ts; if ((!ts.rangeContainsRange(func, node) || ts.rangeContainsRange(func.body, node) && !considerFunctionBodies)) { return undefined; } - if (ts.isExpression(func.body)) { - return { - info: { - func: func, - addBraces: true, - expression: func.body - } - }; + if (refactor.refactorKindBeginsWith(addBracesAction.kind, kind) && ts.isExpression(func.body)) { + return { func: func, addBraces: true, expression: func.body }; } - else if (func.body.statements.length === 1) { + else if (refactor.refactorKindBeginsWith(removeBracesAction.kind, kind) && ts.isBlock(func.body) && func.body.statements.length === 1) { var firstStatement = ts.first(func.body.statements); if (ts.isReturnStatement(firstStatement)) { - return { - info: { - func: func, - addBraces: false, - expression: firstStatement.expression, - returnStatement: firstStatement - } - }; + return { func: func, addBraces: false, expression: firstStatement.expression, returnStatement: firstStatement }; } } return undefined; @@ -145241,7 +147514,17 @@ var ts; (function (convertParamsToDestructuredObject) { var refactorName = "Convert parameters to destructured object"; var minimumParameterLength = 2; - refactor.registerRefactor(refactorName, { getEditsForAction: getEditsForAction, getAvailableActions: getAvailableActions }); + var refactorDescription = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_parameters_to_destructured_object); + var toDestructuredAction = { + name: refactorName, + description: refactorDescription, + kind: "refactor.rewrite.parameters.toDestructured" + }; + refactor.registerRefactor(refactorName, { + kinds: [toDestructuredAction.kind], + getEditsForAction: getEditsForAction, + getAvailableActions: getAvailableActions + }); function getAvailableActions(context) { var file = context.file, startPosition = context.startPosition; var isJSFile = ts.isSourceFileJS(file); @@ -145250,14 +147533,10 @@ var ts; var functionDeclaration = getFunctionDeclarationAtPosition(file, startPosition, context.program.getTypeChecker()); if (!functionDeclaration) return ts.emptyArray; - var description = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_parameters_to_destructured_object); return [{ name: refactorName, - description: description, - actions: [{ - name: refactorName, - description: description - }] + description: refactorDescription, + actions: [toDestructuredAction] }]; } function getEditsForAction(context, actionName) { @@ -145274,13 +147553,13 @@ var ts; return { edits: [] }; // TODO: GH#30113 } function doChange(sourceFile, program, host, changes, functionDeclaration, groupedReferences) { - var newParamDeclaration = ts.map(createNewParameters(functionDeclaration, program, host), function (param) { return ts.getSynthesizedDeepClone(param); }); - changes.replaceNodeRangeWithNodes(sourceFile, ts.first(functionDeclaration.parameters), ts.last(functionDeclaration.parameters), newParamDeclaration, { joiner: ", ", - // indentation is set to 0 because otherwise the object parameter will be indented if there is a `this` parameter - indentation: 0, - leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll, - trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Include - }); + var signature = groupedReferences.signature; + var newFunctionDeclarationParams = ts.map(createNewParameters(functionDeclaration, program, host), function (param) { return ts.getSynthesizedDeepClone(param); }); + if (signature) { + var newSignatureParams = ts.map(createNewParameters(signature, program, host), function (param) { return ts.getSynthesizedDeepClone(param); }); + replaceParameters(signature, newSignatureParams); + } + replaceParameters(functionDeclaration, newFunctionDeclarationParams); var functionCalls = ts.sortAndDeduplicate(groupedReferences.functionCalls, /*comparer*/ function (a, b) { return ts.compareValues(a.pos, b.pos); }); for (var _i = 0, functionCalls_1 = functionCalls; _i < functionCalls_1.length; _i++) { var call = functionCalls_1[_i]; @@ -145289,11 +147568,20 @@ var ts; changes.replaceNodeRange(ts.getSourceFileOfNode(call), ts.first(call.arguments), ts.last(call.arguments), newArgument, { leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll, trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Include }); } } + function replaceParameters(declarationOrSignature, parameterDeclarations) { + changes.replaceNodeRangeWithNodes(sourceFile, ts.first(declarationOrSignature.parameters), ts.last(declarationOrSignature.parameters), parameterDeclarations, { + joiner: ", ", + // indentation is set to 0 because otherwise the object parameter will be indented if there is a `this` parameter + indentation: 0, + leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll, + trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Include + }); + } } function getGroupedReferences(functionDeclaration, program, cancellationToken) { var functionNames = getFunctionNames(functionDeclaration); var classNames = ts.isConstructorDeclaration(functionDeclaration) ? getClassNames(functionDeclaration) : []; - var names = ts.deduplicate(__spreadArrays(functionNames, classNames), ts.equateValues); + var names = ts.deduplicate(__spreadArray(__spreadArray([], functionNames), classNames), ts.equateValues); var checker = program.getTypeChecker(); var references = ts.flatMap(names, /*mapfn*/ function (/*mapfn*/ name) { return ts.FindAllReferences.getReferenceEntriesForNode(-1, name, program, program.getSourceFiles(), cancellationToken); }); var groupedReferences = groupReferences(references); @@ -145307,12 +147595,38 @@ var ts; var functionSymbols = ts.map(functionNames, getSymbolTargetAtLocation); var classSymbols = ts.map(classNames, getSymbolTargetAtLocation); var isConstructor = ts.isConstructorDeclaration(functionDeclaration); + var contextualSymbols = ts.map(functionNames, function (name) { return getSymbolForContextualType(name, checker); }); for (var _i = 0, referenceEntries_1 = referenceEntries; _i < referenceEntries_1.length; _i++) { var entry = referenceEntries_1[_i]; - if (entry.kind !== 1 /* Node */) { + if (entry.kind === 0 /* Span */) { groupedReferences.valid = false; continue; } + /* Declarations in object literals may be implementations of method signatures which have a different symbol from the declaration + For example: + interface IFoo { m(a: number): void } + const foo: IFoo = { m(a: number): void {} } + In these cases we get the symbol for the signature from the contextual type. + */ + if (ts.contains(contextualSymbols, getSymbolTargetAtLocation(entry.node))) { + if (isValidMethodSignature(entry.node.parent)) { + groupedReferences.signature = entry.node.parent; + continue; + } + var call = entryToFunctionCall(entry); + if (call) { + groupedReferences.functionCalls.push(call); + continue; + } + } + var contextualSymbol = getSymbolForContextualType(entry.node, checker); + if (contextualSymbol && ts.contains(contextualSymbols, contextualSymbol)) { + var decl = entryToDeclaration(entry); + if (decl) { + groupedReferences.declarations.push(decl); + continue; + } + } /* We compare symbols because in some cases find all references wil return a reference that may or may not be to the refactored function. Example from the refactorConvertParamsToDestructuredObject_methodCallUnion.ts test: class A { foo(a: number, b: number) { return a + b; } } @@ -145375,6 +147689,19 @@ var ts; return symbol && ts.getSymbolTarget(symbol, checker); } } + /** + * Gets the symbol for the contextual type of the node if it is not a union or intersection. + */ + function getSymbolForContextualType(node, checker) { + var element = ts.getContainingObjectLiteralElement(node); + if (element) { + var contextualType = checker.getContextualTypeForObjectLiteralElement(element); + var symbol = contextualType === null || contextualType === void 0 ? void 0 : contextualType.getSymbol(); + if (symbol && !(ts.getCheckFlags(symbol) & 6 /* Synthetic */)) { + return symbol; + } + } + } function entryToImportOrExport(entry) { var node = entry.node; if (ts.isImportSpecifier(node.parent) @@ -145482,6 +147809,9 @@ var ts; } return false; } + function isValidMethodSignature(node) { + return ts.isMethodSignature(node) && (ts.isInterfaceDeclaration(node.parent) || ts.isTypeLiteralNode(node.parent)); + } function isValidFunctionDeclaration(functionDeclaration, checker) { if (!isValidParameterNodeArray(functionDeclaration.parameters, checker)) return false; @@ -145489,6 +147819,11 @@ var ts; case 251 /* FunctionDeclaration */: return hasNameOrDefault(functionDeclaration) && isSingleImplementation(functionDeclaration, checker); case 165 /* MethodDeclaration */: + if (ts.isObjectLiteralExpression(functionDeclaration.parent)) { + var contextualSymbol = getSymbolForContextualType(functionDeclaration.name, checker); + // don't offer the refactor when there are multiple signatures since we won't know which ones the user wants to change + return (contextualSymbol === null || contextualSymbol === void 0 ? void 0 : contextualSymbol.declarations.length) === 1 && isSingleImplementation(functionDeclaration, checker); + } return isSingleImplementation(functionDeclaration, checker); case 166 /* Constructor */: if (ts.isClassDeclaration(functionDeclaration.parent)) { @@ -145706,14 +148041,27 @@ var ts; (function (convertStringOrTemplateLiteral) { var refactorName = "Convert to template string"; var refactorDescription = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_template_string); - refactor.registerRefactor(refactorName, { getEditsForAction: getEditsForAction, getAvailableActions: getAvailableActions }); + var convertStringAction = { + name: refactorName, + description: refactorDescription, + kind: "refactor.rewrite.string" + }; + refactor.registerRefactor(refactorName, { + kinds: [convertStringAction.kind], + getEditsForAction: getEditsForAction, + getAvailableActions: getAvailableActions + }); function getAvailableActions(context) { var file = context.file, startPosition = context.startPosition; var node = getNodeOrParentOfParentheses(file, startPosition); var maybeBinary = getParentBinaryExpression(node); var refactorInfo = { name: refactorName, description: refactorDescription, actions: [] }; if (ts.isBinaryExpression(maybeBinary) && isStringConcatenationValid(maybeBinary)) { - refactorInfo.actions.push({ name: refactorName, description: refactorDescription }); + refactorInfo.actions.push(convertStringAction); + return [refactorInfo]; + } + else if (context.preferences.provideRefactorNotApplicableReason) { + refactorInfo.actions.push(__assign(__assign({}, convertStringAction), { notApplicableReason: ts.getLocaleSpecificMessage(ts.Diagnostics.Can_only_convert_string_concatenation) })); return [refactorInfo]; } return ts.emptyArray; @@ -145767,6 +148115,7 @@ var ts; case 201 /* PropertyAccessExpression */: case 202 /* ElementAccessExpression */: return false; + case 218 /* TemplateExpression */: case 216 /* BinaryExpression */: return !(ts.isBinaryExpression(n.parent) && isNotEqualsOperator(n.parent)); default: @@ -145782,7 +148131,7 @@ var ts; function treeToArray(current) { if (ts.isBinaryExpression(current)) { var _a = treeToArray(current.left), nodes = _a.nodes, operators = _a.operators, leftHasString = _a.containsString, leftOperatorValid = _a.areOperatorsValid; - if (!leftHasString && !ts.isStringLiteral(current.right)) { + if (!leftHasString && !ts.isStringLiteral(current.right) && !ts.isTemplateExpression(current.right)) { return { nodes: [current], operators: [], containsString: false, areOperatorsValid: true }; } var currentOperatorValid = current.operatorToken.kind === 39 /* PlusToken */; @@ -145812,13 +148161,22 @@ var ts; }; }; function concatConsecutiveString(index, nodes) { - var text = ""; var indexes = []; - while (index < nodes.length && ts.isStringLiteral(nodes[index])) { - var stringNode = nodes[index]; - text = text + stringNode.text; - indexes.push(index); - index++; + var text = ""; + while (index < nodes.length) { + var node = nodes[index]; + if (ts.isStringLiteralLike(node)) { + text = text + node.text; + indexes.push(index); + index++; + } + else if (ts.isTemplateExpression(node)) { + text = text + node.head.text; + break; + } + else { + break; + } } return [index, text, indexes]; } @@ -145835,27 +148193,45 @@ var ts; var templateSpans = []; var templateHead = ts.factory.createTemplateHead(headText); copyCommentFromStringLiterals(headIndexes, templateHead); - for (var i = begin; i < nodes.length; i++) { + var _loop_19 = function (i) { var currentNode = getExpressionFromParenthesesOrExpression(nodes[i]); copyOperatorComments(i, currentNode); var _c = concatConsecutiveString(i + 1, nodes), newIndex = _c[0], subsequentText = _c[1], stringIndexes = _c[2]; i = newIndex - 1; - var templatePart = i === nodes.length - 1 ? ts.factory.createTemplateTail(subsequentText) : ts.factory.createTemplateMiddle(subsequentText); - copyCommentFromStringLiterals(stringIndexes, templatePart); - templateSpans.push(ts.factory.createTemplateSpan(currentNode, templatePart)); + var isLast = i === nodes.length - 1; + if (ts.isTemplateExpression(currentNode)) { + var spans = ts.map(currentNode.templateSpans, function (span, index) { + copyExpressionComments(span); + var nextSpan = currentNode.templateSpans[index + 1]; + var text = span.literal.text + (nextSpan ? "" : subsequentText); + return ts.factory.createTemplateSpan(span.expression, isLast ? ts.factory.createTemplateTail(text) : ts.factory.createTemplateMiddle(text)); + }); + templateSpans.push.apply(templateSpans, spans); + } + else { + var templatePart = isLast ? ts.factory.createTemplateTail(subsequentText) : ts.factory.createTemplateMiddle(subsequentText); + copyCommentFromStringLiterals(stringIndexes, templatePart); + templateSpans.push(ts.factory.createTemplateSpan(currentNode, templatePart)); + } + out_i_1 = i; + }; + var out_i_1; + for (var i = begin; i < nodes.length; i++) { + _loop_19(i); + i = out_i_1; } return ts.factory.createTemplateExpression(templateHead, templateSpans); } // to copy comments following the opening & closing parentheses // "foo" + ( /* comment */ 5 + 5 ) /* comment */ + "bar" - function copyCommentsWhenParenthesized(node) { + function copyExpressionComments(node) { var file = node.getSourceFile(); ts.copyTrailingComments(node, node.expression, file, 3 /* MultiLineCommentTrivia */, /* hasTrailingNewLine */ false); ts.copyTrailingAsLeadingComments(node.expression, node.expression, file, 3 /* MultiLineCommentTrivia */, /* hasTrailingNewLine */ false); } function getExpressionFromParenthesesOrExpression(node) { if (ts.isParenthesizedExpression(node)) { - copyCommentsWhenParenthesized(node); + copyExpressionComments(node); node = node.expression; } return node; @@ -145872,42 +148248,72 @@ var ts; (function (convertArrowFunctionOrFunctionExpression) { var refactorName = "Convert arrow function or function expression"; var refactorDescription = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_arrow_function_or_function_expression); - var toAnonymousFunctionActionName = "Convert to anonymous function"; - var toNamedFunctionActionName = "Convert to named function"; - var toArrowFunctionActionName = "Convert to arrow function"; - var toAnonymousFunctionActionDescription = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_anonymous_function); - var toNamedFunctionActionDescription = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_named_function); - var toArrowFunctionActionDescription = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_arrow_function); - refactor.registerRefactor(refactorName, { getEditsForAction: getEditsForAction, getAvailableActions: getAvailableActions }); + var toAnonymousFunctionAction = { + name: "Convert to anonymous function", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_anonymous_function), + kind: "refactor.rewrite.function.anonymous", + }; + var toNamedFunctionAction = { + name: "Convert to named function", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_named_function), + kind: "refactor.rewrite.function.named", + }; + var toArrowFunctionAction = { + name: "Convert to arrow function", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_arrow_function), + kind: "refactor.rewrite.function.arrow", + }; + refactor.registerRefactor(refactorName, { + kinds: [ + toAnonymousFunctionAction.kind, + toNamedFunctionAction.kind, + toArrowFunctionAction.kind + ], + getEditsForAction: getEditsForAction, + getAvailableActions: getAvailableActions + }); function getAvailableActions(context) { - var file = context.file, startPosition = context.startPosition, program = context.program; + var file = context.file, startPosition = context.startPosition, program = context.program, kind = context.kind; var info = getFunctionInfo(file, startPosition, program); if (!info) return ts.emptyArray; var selectedVariableDeclaration = info.selectedVariableDeclaration, func = info.func; var possibleActions = []; - if (selectedVariableDeclaration || (ts.isArrowFunction(func) && ts.isVariableDeclaration(func.parent))) { - possibleActions.push({ - name: toNamedFunctionActionName, - description: toNamedFunctionActionDescription - }); + var errors = []; + if (refactor.refactorKindBeginsWith(toNamedFunctionAction.kind, kind)) { + var error = selectedVariableDeclaration || (ts.isArrowFunction(func) && ts.isVariableDeclaration(func.parent)) ? + undefined : ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_convert_to_named_function); + if (error) { + errors.push(__assign(__assign({}, toNamedFunctionAction), { notApplicableReason: error })); + } + else { + possibleActions.push(toNamedFunctionAction); + } } - if (!selectedVariableDeclaration && ts.isArrowFunction(func)) { - possibleActions.push({ - name: toAnonymousFunctionActionName, - description: toAnonymousFunctionActionDescription - }); + if (refactor.refactorKindBeginsWith(toAnonymousFunctionAction.kind, kind)) { + var error = !selectedVariableDeclaration && ts.isArrowFunction(func) ? + undefined : ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_convert_to_anonymous_function); + if (error) { + errors.push(__assign(__assign({}, toAnonymousFunctionAction), { notApplicableReason: error })); + } + else { + possibleActions.push(toAnonymousFunctionAction); + } } - if (ts.isFunctionExpression(func)) { - possibleActions.push({ - name: toArrowFunctionActionName, - description: toArrowFunctionActionDescription - }); + if (refactor.refactorKindBeginsWith(toArrowFunctionAction.kind, kind)) { + var error = ts.isFunctionExpression(func) ? undefined : ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_convert_to_arrow_function); + if (error) { + errors.push(__assign(__assign({}, toArrowFunctionAction), { notApplicableReason: error })); + } + else { + possibleActions.push(toArrowFunctionAction); + } } return [{ name: refactorName, description: refactorDescription, - actions: possibleActions + actions: possibleActions.length === 0 && context.preferences.provideRefactorNotApplicableReason ? + errors : possibleActions }]; } function getEditsForAction(context, actionName) { @@ -145918,16 +148324,16 @@ var ts; var func = info.func; var edits = []; switch (actionName) { - case toAnonymousFunctionActionName: + case toAnonymousFunctionAction.name: edits.push.apply(edits, getEditInfoForConvertToAnonymousFunction(context, func)); break; - case toNamedFunctionActionName: + case toNamedFunctionAction.name: var variableInfo = getVariableInfo(func); if (!variableInfo) return undefined; edits.push.apply(edits, getEditInfoForConvertToNamedFunction(context, func, variableInfo)); break; - case toArrowFunctionActionName: + case toArrowFunctionAction.name: if (!ts.isFunctionExpression(func)) return undefined; edits.push.apply(edits, getEditInfoForConvertToArrowFunction(context, func)); @@ -145952,16 +148358,17 @@ var ts; } function getFunctionInfo(file, startPosition, program) { var token = ts.getTokenAtPosition(file, startPosition); - var arrowFunc = getArrowFunctionFromVariableDeclaration(token.parent); - if (arrowFunc && !containingThis(arrowFunc.body)) - return { selectedVariableDeclaration: true, func: arrowFunc }; - var maybeFunc = ts.getContainingFunction(token); var typeChecker = program.getTypeChecker(); + var func = tryGetFunctionFromVariableDeclaration(file, typeChecker, token.parent); + if (func && !containingThis(func.body)) { + return { selectedVariableDeclaration: true, func: func }; + } + var maybeFunc = ts.getContainingFunction(token); if (maybeFunc && (ts.isFunctionExpression(maybeFunc) || ts.isArrowFunction(maybeFunc)) && !ts.rangeContainsRange(maybeFunc.body, token) && !containingThis(maybeFunc.body)) { - if ((ts.isFunctionExpression(maybeFunc) && maybeFunc.name && ts.FindAllReferences.Core.isSymbolReferencedInFile(maybeFunc.name, typeChecker, file))) + if (ts.isFunctionExpression(maybeFunc) && isFunctionReferencedInFile(file, typeChecker, maybeFunc)) return undefined; return { selectedVariableDeclaration: false, func: maybeFunc }; } @@ -145970,14 +148377,16 @@ var ts; function isSingleVariableDeclaration(parent) { return ts.isVariableDeclaration(parent) || (ts.isVariableDeclarationList(parent) && parent.declarations.length === 1); } - function getArrowFunctionFromVariableDeclaration(parent) { - if (!isSingleVariableDeclaration(parent)) + function tryGetFunctionFromVariableDeclaration(sourceFile, typeChecker, parent) { + if (!isSingleVariableDeclaration(parent)) { return undefined; - var variableDeclaration = ts.isVariableDeclaration(parent) ? parent : parent.declarations[0]; + } + var variableDeclaration = ts.isVariableDeclaration(parent) ? parent : ts.first(parent.declarations); var initializer = variableDeclaration.initializer; - if (!initializer || !ts.isArrowFunction(initializer)) - return undefined; - return initializer; + if (initializer && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer) && !isFunctionReferencedInFile(sourceFile, typeChecker, initializer))) { + return initializer; + } + return undefined; } function convertToBlock(body) { if (ts.isExpression(body)) { @@ -146038,9 +148447,106 @@ var ts; function canBeConvertedToExpression(body, head) { return body.statements.length === 1 && ((ts.isReturnStatement(head) && !!head.expression)); } + function isFunctionReferencedInFile(sourceFile, typeChecker, node) { + return !!node.name && ts.FindAllReferences.Core.isSymbolReferencedInFile(node.name, typeChecker, sourceFile); + } })(convertArrowFunctionOrFunctionExpression = refactor.convertArrowFunctionOrFunctionExpression || (refactor.convertArrowFunctionOrFunctionExpression = {})); })(refactor = ts.refactor || (ts.refactor = {})); })(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var inferFunctionReturnType; + (function (inferFunctionReturnType) { + var refactorName = "Infer function return type"; + var refactorDescription = ts.Diagnostics.Infer_function_return_type.message; + var inferReturnTypeAction = { + name: refactorName, + description: refactorDescription, + kind: "refactor.rewrite.function.returnType" + }; + refactor.registerRefactor(refactorName, { + kinds: [inferReturnTypeAction.kind], + getEditsForAction: getEditsForAction, + getAvailableActions: getAvailableActions + }); + function getEditsForAction(context) { + var info = getInfo(context); + if (info && !refactor.isRefactorErrorInfo(info)) { + var edits = ts.textChanges.ChangeTracker.with(context, function (t) { + return t.tryInsertTypeAnnotation(context.file, info.declaration, info.returnTypeNode); + }); + return { renameFilename: undefined, renameLocation: undefined, edits: edits }; + } + return undefined; + } + function getAvailableActions(context) { + var info = getInfo(context); + if (!info) + return ts.emptyArray; + if (!refactor.isRefactorErrorInfo(info)) { + return [{ + name: refactorName, + description: refactorDescription, + actions: [inferReturnTypeAction] + }]; + } + if (context.preferences.provideRefactorNotApplicableReason) { + return [{ + name: refactorName, + description: refactorDescription, + actions: [__assign(__assign({}, inferReturnTypeAction), { notApplicableReason: info.error })] + }]; + } + return ts.emptyArray; + } + function getInfo(context) { + if (ts.isInJSFile(context.file) || !refactor.refactorKindBeginsWith(inferReturnTypeAction.kind, context.kind)) + return; + var token = ts.getTokenAtPosition(context.file, context.startPosition); + var declaration = ts.findAncestor(token, isConvertibleDeclaration); + if (!declaration || !declaration.body || declaration.type) { + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Return_type_must_be_inferred_from_a_function) }; + } + var typeChecker = context.program.getTypeChecker(); + var returnType = tryGetReturnType(typeChecker, declaration); + if (!returnType) { + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_determine_function_return_type) }; + } + ; + var returnTypeNode = typeChecker.typeToTypeNode(returnType, declaration, 1 /* NoTruncation */); + if (returnTypeNode) { + return { declaration: declaration, returnTypeNode: returnTypeNode }; + } + } + function isConvertibleDeclaration(node) { + switch (node.kind) { + case 251 /* FunctionDeclaration */: + case 208 /* FunctionExpression */: + case 209 /* ArrowFunction */: + case 165 /* MethodDeclaration */: + return true; + default: + return false; + } + } + function tryGetReturnType(typeChecker, node) { + if (typeChecker.isImplementationOfOverload(node)) { + var signatures = typeChecker.getTypeAtLocation(node).getCallSignatures(); + if (signatures.length > 1) { + return typeChecker.getUnionType(ts.mapDefined(signatures, function (s) { return s.getReturnType(); })); + } + } + var signature = typeChecker.getSignatureFromDeclaration(node); + if (signature) { + return typeChecker.getReturnTypeOfSignature(signature); + } + } + })(inferFunctionReturnType = refactor.inferFunctionReturnType || (refactor.inferFunctionReturnType = {})); + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); var ts; (function (ts) { /** The version of the language service API */ @@ -146482,7 +148988,7 @@ var ts; }; SignatureObject.prototype.getJsDocTags = function () { if (this.jsDocTags === undefined) { - this.jsDocTags = this.declaration ? ts.JsDoc.getJsDocTagsFromDeclarations([this.declaration]) : []; + this.jsDocTags = this.declaration ? getJsDocTags([this.declaration], this.checker) : []; } return this.jsDocTags; }; @@ -146496,13 +149002,25 @@ var ts; function hasJSDocInheritDocTag(node) { return ts.getJSDocTags(node).some(function (tag) { return tag.tagName.text === "inheritDoc"; }); } + function getJsDocTags(declarations, checker) { + var tags = ts.JsDoc.getJsDocTagsFromDeclarations(declarations); + if (tags.length === 0 || declarations.some(hasJSDocInheritDocTag)) { + ts.forEachUnique(declarations, function (declaration) { + var inheritedTags = findBaseOfDeclaration(checker, declaration, function (symbol) { return symbol.getJsDocTags(); }); + if (inheritedTags) { + tags = __spreadArray(__spreadArray([], inheritedTags), tags); + } + }); + } + return tags; + } function getDocumentationComment(declarations, checker) { if (!declarations) return ts.emptyArray; var doc = ts.JsDoc.getJsDocCommentsFromDeclarations(declarations); - if (doc.length === 0 || declarations.some(hasJSDocInheritDocTag)) { + if (checker && (doc.length === 0 || declarations.some(hasJSDocInheritDocTag))) { ts.forEachUnique(declarations, function (declaration) { - var inheritedDocs = findInheritedJSDocComments(declaration, declaration.symbol.name, checker); // TODO: GH#18217 + var inheritedDocs = findBaseOfDeclaration(checker, declaration, function (symbol) { return symbol.getDocumentationComment(checker); }); // TODO: GH#16312 Return a ReadonlyArray, avoid copying inheritedDocs if (inheritedDocs) doc = doc.length === 0 ? inheritedDocs.slice() : inheritedDocs.concat(ts.lineBreakPart(), doc); @@ -146510,20 +149028,10 @@ var ts; } return doc; } - /** - * Attempts to find JSDoc comments for possibly-inherited properties. Checks superclasses then traverses - * implemented interfaces until a symbol is found with the same name and with documentation. - * @param declaration The possibly-inherited declaration to find comments for. - * @param propertyName The name of the possibly-inherited property. - * @param typeChecker A TypeChecker, used to find inherited properties. - * @returns A filled array of documentation comments if any were found, otherwise an empty array. - */ - function findInheritedJSDocComments(declaration, propertyName, typeChecker) { + function findBaseOfDeclaration(checker, declaration, cb) { return ts.firstDefined(declaration.parent ? ts.getAllSuperTypeNodes(declaration.parent) : ts.emptyArray, function (superTypeNode) { - var superType = typeChecker.getTypeAtLocation(superTypeNode); - var baseProperty = superType && typeChecker.getPropertyOfType(superType, propertyName); - var inheritedDocs = baseProperty && baseProperty.getDocumentationComment(typeChecker); - return inheritedDocs && inheritedDocs.length ? inheritedDocs : undefined; + var symbol = checker.getPropertyOfType(checker.getTypeAtLocation(superTypeNode), declaration.symbol.name); + return symbol ? cb(symbol) : undefined; }); } var SourceFileObject = /** @class */ (function (_super) { @@ -146925,15 +149433,20 @@ var ts; return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, /*setNodeParents*/ true, sourceFile.scriptKind); } ts.updateLanguageServiceSourceFile = updateLanguageServiceSourceFile; + var NoopCancellationToken = { + isCancellationRequested: ts.returnFalse, + throwIfCancellationRequested: ts.noop, + }; var CancellationTokenObject = /** @class */ (function () { function CancellationTokenObject(cancellationToken) { this.cancellationToken = cancellationToken; } CancellationTokenObject.prototype.isCancellationRequested = function () { - return !!this.cancellationToken && this.cancellationToken.isCancellationRequested(); + return this.cancellationToken.isCancellationRequested(); }; CancellationTokenObject.prototype.throwIfCancellationRequested = function () { if (this.isCancellationRequested()) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* Session */, "cancellationThrown", { kind: "CancellationTokenObject" }); throw new ts.OperationCanceledException(); } }; @@ -146963,6 +149476,7 @@ var ts; }; ThrottledCancellationToken.prototype.throwIfCancellationRequested = function () { if (this.isCancellationRequested()) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* Session */, "cancellationThrown", { kind: "ThrottledCancellationToken" }); throw new ts.OperationCanceledException(); } }; @@ -146988,7 +149502,7 @@ var ts; "provideCallHierarchyIncomingCalls", "provideCallHierarchyOutgoingCalls", ]; - var invalidOperationsInSyntacticMode = __spreadArrays(invalidOperationsInPartialSemanticMode, [ + var invalidOperationsInSyntacticMode = __spreadArray(__spreadArray([], invalidOperationsInPartialSemanticMode), [ "getCompletionsAtPosition", "getCompletionEntryDetails", "getCompletionEntrySymbol", @@ -147025,7 +149539,9 @@ var ts; var program; var lastProjectVersion; var lastTypesRootVersion = 0; - var cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken()); + var cancellationToken = host.getCancellationToken + ? new CancellationTokenObject(host.getCancellationToken()) + : NoopCancellationToken; var currentDirectory = host.getCurrentDirectory(); // Check if the localized messages json is set, otherwise query the host for it if (!ts.localizedDiagnosticMessages && host.getLocalizedDiagnosticMessages) { @@ -147269,7 +149785,7 @@ var ts; } // If '-d' is enabled, check for emitter error. One example of emitter error is export class implements non-export interface var declarationDiagnostics = program.getDeclarationDiagnostics(targetSourceFile, cancellationToken); - return __spreadArrays(semanticDiagnostics, declarationDiagnostics); + return __spreadArray(__spreadArray([], semanticDiagnostics), declarationDiagnostics); } function getSuggestionDiagnostics(fileName) { synchronizeHostData(); @@ -147277,7 +149793,7 @@ var ts; } function getCompilerOptionsDiagnostics() { synchronizeHostData(); - return __spreadArrays(program.getOptionsDiagnostics(cancellationToken), program.getGlobalDiagnostics(cancellationToken)); + return __spreadArray(__spreadArray([], program.getOptionsDiagnostics(cancellationToken)), program.getGlobalDiagnostics(cancellationToken)); } function getCompletionsAtPosition(fileName, position, options) { if (options === void 0) { options = ts.emptyOptions; } @@ -147324,7 +149840,7 @@ var ts; }), symbolKind = _a.symbolKind, displayParts = _a.displayParts, documentation = _a.documentation, tags = _a.tags; return { kind: symbolKind, - kindModifiers: ts.SymbolDisplay.getSymbolModifiers(symbol), + kindModifiers: ts.SymbolDisplay.getSymbolModifiers(typeChecker, symbol), textSpan: ts.createTextSpanFromNode(nodeForQuickInfo, sourceFile), displayParts: displayParts, documentation: documentation, @@ -147414,6 +149930,10 @@ var ts; synchronizeHostData(); return ts.FindAllReferences.findReferencedSymbols(program, cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position); } + function getFileReferences(fileName) { + synchronizeHostData(); + return ts.FindAllReferences.Core.getReferencesForFileName(fileName, program, program.getSourceFiles()).map(ts.FindAllReferences.toReferenceEntry); + } function getNavigateToItems(searchValue, maxResultCount, fileName, excludeDtsFiles) { if (excludeDtsFiles === void 0) { excludeDtsFiles = false; } synchronizeHostData(); @@ -147637,8 +150157,8 @@ var ts; ? host.installPackage({ fileName: getPath(action.file), packageName: action.packageName }) : Promise.reject("Host does not implement `installPackage`"); } - function getDocCommentTemplateAtPosition(fileName, position) { - return ts.JsDoc.getDocCommentTemplateAtPosition(ts.getNewLineOrDefaultFromHost(host), syntaxTreeCache.getCurrentSourceFile(fileName), position); + function getDocCommentTemplateAtPosition(fileName, position, options) { + return ts.JsDoc.getDocCommentTemplateAtPosition(ts.getNewLineOrDefaultFromHost(host), syntaxTreeCache.getCurrentSourceFile(fileName), position, options); } function isValidBraceCompletionAtPosition(fileName, position, openingBrace) { // '<' is currently not supported, figuring out if we're in a Generic Type vs. a comparison is too @@ -148023,7 +150543,7 @@ var ts; synchronizeHostData(); return ts.Rename.getRenameInfo(program, getValidSourceFile(fileName), position, options); } - function getRefactorContext(file, positionOrRange, preferences, formatOptions, triggerReason) { + function getRefactorContext(file, positionOrRange, preferences, formatOptions, triggerReason, kind) { var _a = typeof positionOrRange === "number" ? [positionOrRange, undefined] : [positionOrRange.pos, positionOrRange.end], startPosition = _a[0], endPosition = _a[1]; return { file: file, @@ -148035,16 +150555,17 @@ var ts; cancellationToken: cancellationToken, preferences: preferences, triggerReason: triggerReason, + kind: kind }; } function getSmartSelectionRange(fileName, position) { return ts.SmartSelectionRange.getSmartSelectionRange(position, syntaxTreeCache.getCurrentSourceFile(fileName)); } - function getApplicableRefactors(fileName, positionOrRange, preferences, triggerReason) { + function getApplicableRefactors(fileName, positionOrRange, preferences, triggerReason, kind) { if (preferences === void 0) { preferences = ts.emptyOptions; } synchronizeHostData(); var file = getValidSourceFile(fileName); - return ts.refactor.getApplicableRefactors(getRefactorContext(file, positionOrRange, preferences, ts.emptyOptions, triggerReason)); + return ts.refactor.getApplicableRefactors(getRefactorContext(file, positionOrRange, preferences, ts.emptyOptions, triggerReason, kind)); } function getEditsForRefactor(fileName, formatOptions, positionOrRange, refactorName, actionName, preferences) { if (preferences === void 0) { preferences = ts.emptyOptions; } @@ -148091,6 +150612,7 @@ var ts; getTypeDefinitionAtPosition: getTypeDefinitionAtPosition, getReferencesAtPosition: getReferencesAtPosition, findReferences: findReferences, + getFileReferences: getFileReferences, getOccurrencesAtPosition: getOccurrencesAtPosition, getDocumentHighlights: getDocumentHighlights, getNameOrDottedNameSpan: getNameOrDottedNameSpan, @@ -148244,7 +150766,7 @@ var ts; var symbol = contextualType.getProperty(name); return symbol ? [symbol] : ts.emptyArray; } - var discriminatedPropertySymbols = ts.mapDefined(contextualType.types, function (t) { return ts.isObjectLiteralExpression(node.parent) && checker.isTypeInvalidDueToUnionDiscriminant(t, node.parent) ? undefined : t.getProperty(name); }); + var discriminatedPropertySymbols = ts.mapDefined(contextualType.types, function (t) { return (ts.isObjectLiteralExpression(node.parent) || ts.isJsxAttributes(node.parent)) && checker.isTypeInvalidDueToUnionDiscriminant(t, node.parent) ? undefined : t.getProperty(name); }); if (unionSymbolOk && (discriminatedPropertySymbols.length === 0 || discriminatedPropertySymbols.length === contextualType.types.length)) { var symbol = contextualType.getProperty(name); if (symbol) @@ -149384,6 +151906,10 @@ var ts; var _this = this; return this.forwardJSONCall("findReferences('" + fileName + "', " + position + ")", function () { return _this.languageService.findReferences(fileName, position); }); }; + LanguageServiceShimObject.prototype.getFileReferences = function (fileName) { + var _this = this; + return this.forwardJSONCall("getFileReferences('" + fileName + ")", function () { return _this.languageService.getFileReferences(fileName); }); + }; LanguageServiceShimObject.prototype.getOccurrencesAtPosition = function (fileName, position) { var _this = this; return this.forwardJSONCall("getOccurrencesAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getOccurrencesAtPosition(fileName, position); }); @@ -149436,9 +151962,9 @@ var ts; return _this.languageService.getFormattingEditsAfterKeystroke(fileName, position, key, localOptions); }); }; - LanguageServiceShimObject.prototype.getDocCommentTemplateAtPosition = function (fileName, position) { + LanguageServiceShimObject.prototype.getDocCommentTemplateAtPosition = function (fileName, position, options) { var _this = this; - return this.forwardJSONCall("getDocCommentTemplateAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getDocCommentTemplateAtPosition(fileName, position); }); + return this.forwardJSONCall("getDocCommentTemplateAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getDocCommentTemplateAtPosition(fileName, position, options); }); }; /// NAVIGATE TO /** Return a list of symbols that are interesting to navigate to */ @@ -149625,7 +152151,7 @@ var ts; typeAcquisition: configFile.typeAcquisition, files: configFile.fileNames, raw: configFile.raw, - errors: realizeDiagnostics(__spreadArrays(result.parseDiagnostics, configFile.errors), "\r\n") + errors: realizeDiagnostics(__spreadArray(__spreadArray([], result.parseDiagnostics), configFile.errors), "\r\n") }; }); }; @@ -149878,9 +152404,13 @@ var ts; /** @deprecated Use `factory.updateFunctionTypeNode` or the factory supplied by your transformation context instead. */ ts.updateFunctionTypeNode = ts.Debug.deprecate(ts.factory.updateFunctionTypeNode, factoryDeprecation); /** @deprecated Use `factory.createConstructorTypeNode` or the factory supplied by your transformation context instead. */ - ts.createConstructorTypeNode = ts.Debug.deprecate(ts.factory.createConstructorTypeNode, factoryDeprecation); + ts.createConstructorTypeNode = ts.Debug.deprecate(function (typeParameters, parameters, type) { + return ts.factory.createConstructorTypeNode(/*modifiers*/ undefined, typeParameters, parameters, type); + }, factoryDeprecation); /** @deprecated Use `factory.updateConstructorTypeNode` or the factory supplied by your transformation context instead. */ - ts.updateConstructorTypeNode = ts.Debug.deprecate(ts.factory.updateConstructorTypeNode, factoryDeprecation); + ts.updateConstructorTypeNode = ts.Debug.deprecate(function (node, typeParameters, parameters, type) { + return ts.factory.updateConstructorTypeNode(node, node.modifiers, typeParameters, parameters, type); + }, factoryDeprecation); /** @deprecated Use `factory.createTypeQueryNode` or the factory supplied by your transformation context instead. */ ts.createTypeQueryNode = ts.Debug.deprecate(ts.factory.createTypeQueryNode, factoryDeprecation); /** @deprecated Use `factory.updateTypeQueryNode` or the factory supplied by your transformation context instead. */ @@ -149957,81 +152487,81 @@ var ts; ts.createBindingElement = ts.Debug.deprecate(ts.factory.createBindingElement, factoryDeprecation); /** @deprecated Use `factory.updateBindingElement` or the factory supplied by your transformation context instead. */ ts.updateBindingElement = ts.Debug.deprecate(ts.factory.updateBindingElement, factoryDeprecation); - /** @deprecated Use `factory.createArrayLiteral` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createArrayLiteralExpression` or the factory supplied by your transformation context instead. */ ts.createArrayLiteral = ts.Debug.deprecate(ts.factory.createArrayLiteralExpression, factoryDeprecation); - /** @deprecated Use `factory.updateArrayLiteral` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateArrayLiteralExpression` or the factory supplied by your transformation context instead. */ ts.updateArrayLiteral = ts.Debug.deprecate(ts.factory.updateArrayLiteralExpression, factoryDeprecation); - /** @deprecated Use `factory.createObjectLiteral` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createObjectLiteralExpression` or the factory supplied by your transformation context instead. */ ts.createObjectLiteral = ts.Debug.deprecate(ts.factory.createObjectLiteralExpression, factoryDeprecation); - /** @deprecated Use `factory.updateObjectLiteral` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateObjectLiteralExpression` or the factory supplied by your transformation context instead. */ ts.updateObjectLiteral = ts.Debug.deprecate(ts.factory.updateObjectLiteralExpression, factoryDeprecation); - /** @deprecated Use `factory.createPropertyAccess` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createPropertyAccessExpression` or the factory supplied by your transformation context instead. */ ts.createPropertyAccess = ts.Debug.deprecate(ts.factory.createPropertyAccessExpression, factoryDeprecation); - /** @deprecated Use `factory.updatePropertyAccess` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updatePropertyAccessExpression` or the factory supplied by your transformation context instead. */ ts.updatePropertyAccess = ts.Debug.deprecate(ts.factory.updatePropertyAccessExpression, factoryDeprecation); /** @deprecated Use `factory.createPropertyAccessChain` or the factory supplied by your transformation context instead. */ ts.createPropertyAccessChain = ts.Debug.deprecate(ts.factory.createPropertyAccessChain, factoryDeprecation); /** @deprecated Use `factory.updatePropertyAccessChain` or the factory supplied by your transformation context instead. */ ts.updatePropertyAccessChain = ts.Debug.deprecate(ts.factory.updatePropertyAccessChain, factoryDeprecation); - /** @deprecated Use `factory.createElementAccess` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createElementAccessExpression` or the factory supplied by your transformation context instead. */ ts.createElementAccess = ts.Debug.deprecate(ts.factory.createElementAccessExpression, factoryDeprecation); - /** @deprecated Use `factory.updateElementAccess` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateElementAccessExpression` or the factory supplied by your transformation context instead. */ ts.updateElementAccess = ts.Debug.deprecate(ts.factory.updateElementAccessExpression, factoryDeprecation); /** @deprecated Use `factory.createElementAccessChain` or the factory supplied by your transformation context instead. */ ts.createElementAccessChain = ts.Debug.deprecate(ts.factory.createElementAccessChain, factoryDeprecation); /** @deprecated Use `factory.updateElementAccessChain` or the factory supplied by your transformation context instead. */ ts.updateElementAccessChain = ts.Debug.deprecate(ts.factory.updateElementAccessChain, factoryDeprecation); - /** @deprecated Use `factory.createCall` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createCallExpression` or the factory supplied by your transformation context instead. */ ts.createCall = ts.Debug.deprecate(ts.factory.createCallExpression, factoryDeprecation); - /** @deprecated Use `factory.updateCall` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateCallExpression` or the factory supplied by your transformation context instead. */ ts.updateCall = ts.Debug.deprecate(ts.factory.updateCallExpression, factoryDeprecation); /** @deprecated Use `factory.createCallChain` or the factory supplied by your transformation context instead. */ ts.createCallChain = ts.Debug.deprecate(ts.factory.createCallChain, factoryDeprecation); /** @deprecated Use `factory.updateCallChain` or the factory supplied by your transformation context instead. */ ts.updateCallChain = ts.Debug.deprecate(ts.factory.updateCallChain, factoryDeprecation); - /** @deprecated Use `factory.createNew` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createNewExpression` or the factory supplied by your transformation context instead. */ ts.createNew = ts.Debug.deprecate(ts.factory.createNewExpression, factoryDeprecation); - /** @deprecated Use `factory.updateNew` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateNewExpression` or the factory supplied by your transformation context instead. */ ts.updateNew = ts.Debug.deprecate(ts.factory.updateNewExpression, factoryDeprecation); /** @deprecated Use `factory.createTypeAssertion` or the factory supplied by your transformation context instead. */ ts.createTypeAssertion = ts.Debug.deprecate(ts.factory.createTypeAssertion, factoryDeprecation); /** @deprecated Use `factory.updateTypeAssertion` or the factory supplied by your transformation context instead. */ ts.updateTypeAssertion = ts.Debug.deprecate(ts.factory.updateTypeAssertion, factoryDeprecation); - /** @deprecated Use `factory.createParen` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createParenthesizedExpression` or the factory supplied by your transformation context instead. */ ts.createParen = ts.Debug.deprecate(ts.factory.createParenthesizedExpression, factoryDeprecation); - /** @deprecated Use `factory.updateParen` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateParenthesizedExpression` or the factory supplied by your transformation context instead. */ ts.updateParen = ts.Debug.deprecate(ts.factory.updateParenthesizedExpression, factoryDeprecation); /** @deprecated Use `factory.createFunctionExpression` or the factory supplied by your transformation context instead. */ ts.createFunctionExpression = ts.Debug.deprecate(ts.factory.createFunctionExpression, factoryDeprecation); /** @deprecated Use `factory.updateFunctionExpression` or the factory supplied by your transformation context instead. */ ts.updateFunctionExpression = ts.Debug.deprecate(ts.factory.updateFunctionExpression, factoryDeprecation); - /** @deprecated Use `factory.createDelete` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createDeleteExpression` or the factory supplied by your transformation context instead. */ ts.createDelete = ts.Debug.deprecate(ts.factory.createDeleteExpression, factoryDeprecation); - /** @deprecated Use `factory.updateDelete` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateDeleteExpression` or the factory supplied by your transformation context instead. */ ts.updateDelete = ts.Debug.deprecate(ts.factory.updateDeleteExpression, factoryDeprecation); - /** @deprecated Use `factory.createTypeOf` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createTypeOfExpression` or the factory supplied by your transformation context instead. */ ts.createTypeOf = ts.Debug.deprecate(ts.factory.createTypeOfExpression, factoryDeprecation); - /** @deprecated Use `factory.updateTypeOf` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateTypeOfExpression` or the factory supplied by your transformation context instead. */ ts.updateTypeOf = ts.Debug.deprecate(ts.factory.updateTypeOfExpression, factoryDeprecation); - /** @deprecated Use `factory.createVoid` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createVoidExpression` or the factory supplied by your transformation context instead. */ ts.createVoid = ts.Debug.deprecate(ts.factory.createVoidExpression, factoryDeprecation); - /** @deprecated Use `factory.updateVoid` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateVoidExpression` or the factory supplied by your transformation context instead. */ ts.updateVoid = ts.Debug.deprecate(ts.factory.updateVoidExpression, factoryDeprecation); - /** @deprecated Use `factory.createAwait` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createAwaitExpression` or the factory supplied by your transformation context instead. */ ts.createAwait = ts.Debug.deprecate(ts.factory.createAwaitExpression, factoryDeprecation); - /** @deprecated Use `factory.updateAwait` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateAwaitExpression` or the factory supplied by your transformation context instead. */ ts.updateAwait = ts.Debug.deprecate(ts.factory.updateAwaitExpression, factoryDeprecation); - /** @deprecated Use `factory.createPrefix` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createPrefixExpression` or the factory supplied by your transformation context instead. */ ts.createPrefix = ts.Debug.deprecate(ts.factory.createPrefixUnaryExpression, factoryDeprecation); - /** @deprecated Use `factory.updatePrefix` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updatePrefixExpression` or the factory supplied by your transformation context instead. */ ts.updatePrefix = ts.Debug.deprecate(ts.factory.updatePrefixUnaryExpression, factoryDeprecation); - /** @deprecated Use `factory.createPostfix` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createPostfixUnaryExpression` or the factory supplied by your transformation context instead. */ ts.createPostfix = ts.Debug.deprecate(ts.factory.createPostfixUnaryExpression, factoryDeprecation); - /** @deprecated Use `factory.updatePostfix` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updatePostfixUnaryExpression` or the factory supplied by your transformation context instead. */ ts.updatePostfix = ts.Debug.deprecate(ts.factory.updatePostfixUnaryExpression, factoryDeprecation); - /** @deprecated Use `factory.createBinary` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createBinaryExpression` or the factory supplied by your transformation context instead. */ ts.createBinary = ts.Debug.deprecate(ts.factory.createBinaryExpression, factoryDeprecation); - /** @deprecated Use `factory.updateConditional` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateConditionalExpression` or the factory supplied by your transformation context instead. */ ts.updateConditional = ts.Debug.deprecate(ts.factory.updateConditionalExpression, factoryDeprecation); /** @deprecated Use `factory.createTemplateExpression` or the factory supplied by your transformation context instead. */ ts.createTemplateExpression = ts.Debug.deprecate(ts.factory.createTemplateExpression, factoryDeprecation); @@ -150045,11 +152575,11 @@ var ts; ts.createTemplateTail = ts.Debug.deprecate(ts.factory.createTemplateTail, factoryDeprecation); /** @deprecated Use `factory.createNoSubstitutionTemplateLiteral` or the factory supplied by your transformation context instead. */ ts.createNoSubstitutionTemplateLiteral = ts.Debug.deprecate(ts.factory.createNoSubstitutionTemplateLiteral, factoryDeprecation); - /** @deprecated Use `factory.updateYield` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateYieldExpression` or the factory supplied by your transformation context instead. */ ts.updateYield = ts.Debug.deprecate(ts.factory.updateYieldExpression, factoryDeprecation); - /** @deprecated Use `factory.createSpread` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createSpreadExpression` or the factory supplied by your transformation context instead. */ ts.createSpread = ts.Debug.deprecate(ts.factory.createSpreadElement, factoryDeprecation); - /** @deprecated Use `factory.updateSpread` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateSpreadExpression` or the factory supplied by your transformation context instead. */ ts.updateSpread = ts.Debug.deprecate(ts.factory.updateSpreadElement, factoryDeprecation); /** @deprecated Use `factory.createOmittedExpression` or the factory supplied by your transformation context instead. */ ts.createOmittedExpression = ts.Debug.deprecate(ts.factory.createOmittedExpression, factoryDeprecation); @@ -150093,61 +152623,61 @@ var ts; ts.createStatement = ts.Debug.deprecate(ts.factory.createExpressionStatement, factoryDeprecation); /** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */ ts.updateStatement = ts.Debug.deprecate(ts.factory.updateExpressionStatement, factoryDeprecation); - /** @deprecated Use `factory.createIf` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createIfStatement` or the factory supplied by your transformation context instead. */ ts.createIf = ts.Debug.deprecate(ts.factory.createIfStatement, factoryDeprecation); - /** @deprecated Use `factory.updateIf` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateIfStatement` or the factory supplied by your transformation context instead. */ ts.updateIf = ts.Debug.deprecate(ts.factory.updateIfStatement, factoryDeprecation); - /** @deprecated Use `factory.createDo` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createDoStatement` or the factory supplied by your transformation context instead. */ ts.createDo = ts.Debug.deprecate(ts.factory.createDoStatement, factoryDeprecation); - /** @deprecated Use `factory.updateDo` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateDoStatement` or the factory supplied by your transformation context instead. */ ts.updateDo = ts.Debug.deprecate(ts.factory.updateDoStatement, factoryDeprecation); - /** @deprecated Use `factory.createWhile` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createWhileStatement` or the factory supplied by your transformation context instead. */ ts.createWhile = ts.Debug.deprecate(ts.factory.createWhileStatement, factoryDeprecation); - /** @deprecated Use `factory.updateWhile` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateWhileStatement` or the factory supplied by your transformation context instead. */ ts.updateWhile = ts.Debug.deprecate(ts.factory.updateWhileStatement, factoryDeprecation); - /** @deprecated Use `factory.createFor` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createForStatement` or the factory supplied by your transformation context instead. */ ts.createFor = ts.Debug.deprecate(ts.factory.createForStatement, factoryDeprecation); - /** @deprecated Use `factory.updateFor` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateForStatement` or the factory supplied by your transformation context instead. */ ts.updateFor = ts.Debug.deprecate(ts.factory.updateForStatement, factoryDeprecation); - /** @deprecated Use `factory.createForIn` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createForInStatement` or the factory supplied by your transformation context instead. */ ts.createForIn = ts.Debug.deprecate(ts.factory.createForInStatement, factoryDeprecation); - /** @deprecated Use `factory.updateForIn` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateForInStatement` or the factory supplied by your transformation context instead. */ ts.updateForIn = ts.Debug.deprecate(ts.factory.updateForInStatement, factoryDeprecation); - /** @deprecated Use `factory.createForOf` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createForOfStatement` or the factory supplied by your transformation context instead. */ ts.createForOf = ts.Debug.deprecate(ts.factory.createForOfStatement, factoryDeprecation); - /** @deprecated Use `factory.updateForOf` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateForOfStatement` or the factory supplied by your transformation context instead. */ ts.updateForOf = ts.Debug.deprecate(ts.factory.updateForOfStatement, factoryDeprecation); - /** @deprecated Use `factory.createContinue` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createContinueStatement` or the factory supplied by your transformation context instead. */ ts.createContinue = ts.Debug.deprecate(ts.factory.createContinueStatement, factoryDeprecation); - /** @deprecated Use `factory.updateContinue` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateContinueStatement` or the factory supplied by your transformation context instead. */ ts.updateContinue = ts.Debug.deprecate(ts.factory.updateContinueStatement, factoryDeprecation); - /** @deprecated Use `factory.createBreak` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createBreakStatement` or the factory supplied by your transformation context instead. */ ts.createBreak = ts.Debug.deprecate(ts.factory.createBreakStatement, factoryDeprecation); - /** @deprecated Use `factory.updateBreak` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateBreakStatement` or the factory supplied by your transformation context instead. */ ts.updateBreak = ts.Debug.deprecate(ts.factory.updateBreakStatement, factoryDeprecation); - /** @deprecated Use `factory.createReturn` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createReturnStatement` or the factory supplied by your transformation context instead. */ ts.createReturn = ts.Debug.deprecate(ts.factory.createReturnStatement, factoryDeprecation); - /** @deprecated Use `factory.updateReturn` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateReturnStatement` or the factory supplied by your transformation context instead. */ ts.updateReturn = ts.Debug.deprecate(ts.factory.updateReturnStatement, factoryDeprecation); - /** @deprecated Use `factory.createWith` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createWithStatement` or the factory supplied by your transformation context instead. */ ts.createWith = ts.Debug.deprecate(ts.factory.createWithStatement, factoryDeprecation); - /** @deprecated Use `factory.updateWith` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateWithStatement` or the factory supplied by your transformation context instead. */ ts.updateWith = ts.Debug.deprecate(ts.factory.updateWithStatement, factoryDeprecation); - /** @deprecated Use `factory.createSwitch` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createSwitchStatement` or the factory supplied by your transformation context instead. */ ts.createSwitch = ts.Debug.deprecate(ts.factory.createSwitchStatement, factoryDeprecation); - /** @deprecated Use `factory.updateSwitch` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateSwitchStatement` or the factory supplied by your transformation context instead. */ ts.updateSwitch = ts.Debug.deprecate(ts.factory.updateSwitchStatement, factoryDeprecation); - /** @deprecated Use `factory.createLabel` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createLabelStatement` or the factory supplied by your transformation context instead. */ ts.createLabel = ts.Debug.deprecate(ts.factory.createLabeledStatement, factoryDeprecation); - /** @deprecated Use `factory.updateLabel` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateLabelStatement` or the factory supplied by your transformation context instead. */ ts.updateLabel = ts.Debug.deprecate(ts.factory.updateLabeledStatement, factoryDeprecation); - /** @deprecated Use `factory.createThrow` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createThrowStatement` or the factory supplied by your transformation context instead. */ ts.createThrow = ts.Debug.deprecate(ts.factory.createThrowStatement, factoryDeprecation); - /** @deprecated Use `factory.updateThrow` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateThrowStatement` or the factory supplied by your transformation context instead. */ ts.updateThrow = ts.Debug.deprecate(ts.factory.updateThrowStatement, factoryDeprecation); - /** @deprecated Use `factory.createTry` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createTryStatement` or the factory supplied by your transformation context instead. */ ts.createTry = ts.Debug.deprecate(ts.factory.createTryStatement, factoryDeprecation); - /** @deprecated Use `factory.updateTry` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateTryStatement` or the factory supplied by your transformation context instead. */ ts.updateTry = ts.Debug.deprecate(ts.factory.updateTryStatement, factoryDeprecation); /** @deprecated Use `factory.createDebuggerStatement` or the factory supplied by your transformation context instead. */ ts.createDebuggerStatement = ts.Debug.deprecate(ts.factory.createDebuggerStatement, factoryDeprecation); @@ -150355,9 +152885,9 @@ var ts; ts.createPartiallyEmittedExpression = ts.Debug.deprecate(ts.factory.createPartiallyEmittedExpression, factoryDeprecation); /** @deprecated Use `factory.updatePartiallyEmittedExpression` or the factory supplied by your transformation context instead. */ ts.updatePartiallyEmittedExpression = ts.Debug.deprecate(ts.factory.updatePartiallyEmittedExpression, factoryDeprecation); - /** @deprecated Use `factory.createCommaList` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.createCommaListExpression` or the factory supplied by your transformation context instead. */ ts.createCommaList = ts.Debug.deprecate(ts.factory.createCommaListExpression, factoryDeprecation); - /** @deprecated Use `factory.updateCommaList` or the factory supplied by your transformation context instead. */ + /** @deprecated Use `factory.updateCommaListExpression` or the factory supplied by your transformation context instead. */ ts.updateCommaList = ts.Debug.deprecate(ts.factory.updateCommaListExpression, factoryDeprecation); /** @deprecated Use `factory.createBundle` or the factory supplied by your transformation context instead. */ ts.createBundle = ts.Debug.deprecate(ts.factory.createBundle, factoryDeprecation); @@ -150636,14 +153166,14 @@ var ts; * NOTE: It is unsafe to change any properties of a `Node` that relate to its AST children, as those changes won't be * captured with respect to transformations. * - * @deprecated Use `factory.cloneNode` instead and use `setCommentRange` or `setSourceMapRange` and avoid setting `parent`. + * @deprecated Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`. */ ts.getMutableClone = ts.Debug.deprecate(function getMutableClone(node) { var clone = ts.factory.cloneNode(node); ts.setTextRange(clone, node); ts.setParent(clone, node.parent); return clone; - }, { since: "4.0", warnAfter: "4.1", message: "Use `factory.cloneNode` instead and use `setCommentRange` or `setSourceMapRange` and avoid setting `parent`." }); + }, { since: "4.0", warnAfter: "4.1", message: "Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`." }); // #endregion Node Factory top-level exports // DEPRECATION: Renamed node tests // DEPRECATION PLAN: diff --git a/packages/schematics/angular/utility/latest-versions.ts b/packages/schematics/angular/utility/latest-versions.ts index 2e8ba831cab1..a32b924336ad 100644 --- a/packages/schematics/angular/utility/latest-versions.ts +++ b/packages/schematics/angular/utility/latest-versions.ts @@ -11,8 +11,8 @@ export const latestVersions = { Angular: '~12.0.0-next.4', RxJs: '~6.6.0', ZoneJs: '~0.11.4', - TypeScript: '~4.1.2', - TsLib: '^2.0.0', + TypeScript: '~4.2.3', + TsLib: '^2.1.0', // The versions below must be manually updated when making a new devkit release. // For our e2e tests, these versions must match the latest tag present on the branch. diff --git a/packages/schematics/schematics/schematic/files/package.json b/packages/schematics/schematics/schematic/files/package.json index 69c516e832ea..77a126faeb96 100644 --- a/packages/schematics/schematics/schematic/files/package.json +++ b/packages/schematics/schematics/schematic/files/package.json @@ -15,7 +15,7 @@ "dependencies": { "@angular-devkit/core": "^<%= coreVersion %>", "@angular-devkit/schematics": "^<%= schematicsVersion %>", - "typescript": "~4.1.2" + "typescript": "~4.2.3" }, "devDependencies": { "@types/node": "^12.11.1", diff --git a/tests/legacy-cli/e2e/setup/500-create-project.ts b/tests/legacy-cli/e2e/setup/500-create-project.ts index 049f80368d7c..f9c151609e8d 100644 --- a/tests/legacy-cli/e2e/setup/500-create-project.ts +++ b/tests/legacy-cli/e2e/setup/500-create-project.ts @@ -28,6 +28,15 @@ export default async function() { await expectFileToExist(join(process.cwd(), 'test-project')); process.chdir('./test-project'); + // Disable the TS version check to make TS updates easier. + // Only VE does it, but on Ivy the i18n extraction uses VE. + await updateJsonFile('tsconfig.json', config => { + if (!config.angularCompilerOptions) { + config.angularCompilerOptions = {}; + } + config.angularCompilerOptions.disableTypeScriptVersionCheck = true; + }); + // If on CI, the user configuration set above will handle project usage if (!isCI) { // Ensure local test registry is used inside a project diff --git a/tests/legacy-cli/e2e/utils/project.ts b/tests/legacy-cli/e2e/utils/project.ts index 7189d24b9635..e53158b69cb2 100644 --- a/tests/legacy-cli/e2e/utils/project.ts +++ b/tests/legacy-cli/e2e/utils/project.ts @@ -34,28 +34,6 @@ export function ngServe(...args: string[]) { / Compiled successfully./); } - -export async function createProject(name: string, ...args: string[]) { - const extraArgs = []; - - process.chdir(getGlobalVariable('tmp-root')); - await ng('new', name, '--skip-install', ...extraArgs, ...args); - process.chdir(name); - - if (fs.existsSync('tsconfig.json')) { - // Disable the TS version check to make TS updates easier. - // Only VE does it, but on Ivy the i18n extraction uses VE. - await updateJsonFile('tsconfig.json', config => { - if (!config.angularCompilerOptions) { - config.angularCompilerOptions = {}; - } - config.angularCompilerOptions.disableTypeScriptVersionCheck = true; - }); - } - - await prepareProjectForE2e(name); -} - export async function prepareProjectForE2e(name) { const argv: string[] = getGlobalVariable('argv'); diff --git a/yarn.lock b/yarn.lock index 3fe8fa2c0707..9a539275c837 100644 --- a/yarn.lock +++ b/yarn.lock @@ -87,8 +87,7 @@ "@angular/dev-infra-private@https://github.com/angular/dev-infra-private-builds.git#6b6fba2b22d33fe3c52341f4b3970e4087e50557": version "0.0.0" - uid "6b6fba2b22d33fe3c52341f4b3970e4087e50557" - resolved "https://github.com/angular/dev-infra-private-builds.git#6b6fba2b22d33fe3c52341f4b3970e4087e50557" + resolved "https://github.com/angular/dev-infra-private-builds.git#a6b42dabedcf7c724bd36a614ebe9fa99c777e62" dependencies: "@angular/benchpress" "0.2.1" "@bazel/buildifier" "^0.29.0" @@ -12514,7 +12513,12 @@ typedarray@^0.0.6: resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777" integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c= -typescript@4.1.5, typescript@~4.1.2: +typescript@4.2.3: + version "4.2.3" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.2.3.tgz#39062d8019912d43726298f09493d598048c1ce3" + integrity sha512-qOcYwxaByStAWrBf4x0fibwZvMRG+r4cQoTjbPtUlrWjBHbmCAww1i448U0GJ+3cNNEtebDteo/cHOR3xJ4wEw== + +typescript@~4.1.2: version "4.1.5" resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.1.5.tgz#123a3b214aaff3be32926f0d8f1f6e704eb89a72" integrity sha512-6OSu9PTIzmn9TCDiovULTnET6BgXtDYL4Gg4szY+cGsc3JP1dQL8qvE8kShTRx1NIw4Q9IBHlwODjkjWEtMUyA==